├── .gitignore
├── .idea
└── .gitignore
├── LICENCE_fr.txt
├── Readme.md
├── app.py
├── cgu.html
├── check_validity.py
├── code_list.html
├── code_references.py
├── codeislow.py
├── docs
└── Licence_CeCILL_V2.1-fr.txt
├── documentation.html
├── dotenv.example
├── form.html
├── help.html
├── home.html
├── index.html
├── matching.py
├── parsing.py
├── pytest.ini
├── request_api.py
├── requesting.py
├── requirements.txt
├── result_templates.py
├── results.tpl
├── templates
├── about.html
├── base.html
├── cgu.html
├── codes.html
└── home.html
└── tests
├── index.html
├── matching.log
├── needles.csv
├── newtest.doc
├── newtest.docx
├── newtest.md
├── newtest.pdf
├── newtest2.pdf
├── parsing.md
├── test_001_parsing.py
├── test_002_code_references.py
├── test_003_matching.py
├── test_004_request.py
├── test_005_check_validity.py
├── test_006_integration.py
├── testnew.odt
├── testnew.pdf
└── testnew_highlighted.odt
/.gitignore:
--------------------------------------------------------------------------------
1 |
2 | .env
3 | .idea/codeislow.iml
4 | .idea/inspectionProfiles/profiles_settings.xml
5 | .idea/modules.xml
6 | .idea/workspace.xml
7 | .idea/vcs.xml
8 | debug/codeislow-logs-1654119119213.txt
9 | debug/codeislow-logs-1654247407754.txt
10 | tmp/empty
11 | tmp/newtest.docx
12 | tmp/PUAM.docx
13 | tmp/test.docx
14 | .idea/misc.xml
15 | tmp/newtest.pdf
16 | tmp/article.pdf
17 | debug/analyse.txt
18 | debug/Résultats bug.odt
19 | debug/Résultats corrigés.odt
20 | tmp/PUAM-Les-garanties-indemnitaires.odt
21 | tmp/PUAM-Les-garanties-indemnitaires.pdf
22 | tmp/these2.pdf
23 | tmp/these.pdf
24 | .DS_Store
25 | .idea/.name
26 | .idea/inspectionProfiles/Project_Default.xml
27 |
28 | # Byte-compiled / optimized / DLL files
29 | __pycache__/
30 | *.py[cod]
--------------------------------------------------------------------------------
/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /shelf/
3 | /workspace.xml
4 | # Editor-based HTTP Client requests
5 | /httpRequests/
6 | # Datasource local storage ignored files
7 | /dataSources/
8 | /dataSources.local.xml
9 |
--------------------------------------------------------------------------------
/LICENCE_fr.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/emnetter/codeislow/37d84f271e0976b7b8684e5fdd271993efb47d8c/LICENCE_fr.txt
--------------------------------------------------------------------------------
/Readme.md:
--------------------------------------------------------------------------------
1 | # Code is low
2 | Ce programme est conçu pour rechercher, à l'intérieur d'un fichier texte, des références à des articles de codes de droit français (comme le Code civil, le Code de commerce, le Code général des collectivités territoriales...). Il est écrit en Python.
3 |
4 | ## Formulaire utilisateur
5 |
6 | Une page d'accueil est générée en utilisant le [framework Bottle](https://bottlepy.org/docs/dev/). L'utilisateur y indique quel fichier il entend analyser. Les formats actuellement acceptés sont ODT, DOCX et PDF. La taille est limitée à 2 Mo, car le processus d'analyse est gourmand en ressources. Cela est suffisant pour soumettre même des thèses de doctorat aux formats ODT/DOCX. Le PDF doit être utilisé faute d'alternative, par exemple pour soumettre un article de tiers téléchargé en libre accès.
7 |
8 | L'utilisateur indique sur quelles périodes passée et future il convient de vérifier si l'article de code a connu ou connaîtra d'autres versions. Le champ demande des années mais accepte des nombres décimaux, ce qui permet par exemple une vérification sur les six derniers mois.
9 |
10 | ## Ouverture du fichier
11 |
12 | Le fichier est provisoirement enregistré sur le serveur puis passé à différentes libraries selon le format utilisé : [python-docx](https://python-docx.readthedocs.io/en/latest/), [odfpy](https://pypi.org/project/odfpy/) ou [PyPDF2](https://pypi.org/project/PyPDF2/). Dès que le fichier a été transformé en chaîne de caractères, il est supprimé du serveur.
13 |
14 | ## Expressions régulières
15 |
16 | Le programme confronte ensuite l'ensemble du texte à une expression régulière par code de droit français. Cette méthode est simple mais brutale et devrait être améliorée à l'avenir afin de consommer moins de ressources.
17 |
18 | Le résultat des expressions régulières est nettoyé au fur et à mesure, pour anticiper la requête qui sera envoyée à Légifrance. Par exemple, "L. 112-1" doit devenir "L112-1".
19 |
20 | Il ressort de ces opérations un dictionnaire de résultats, distinguant les différents codes. A l'intérieur de chaque code identifié, chaque article est à ce stade rattaché à une seule propriété, son numéro au sein du code.
21 |
22 | ## Interrogation de Légifrance
23 |
24 | La base de données [Légifrance](https://www.legifrance.gouv.fr/), gérée par la [DILA](https://www.dila.premier-ministre.gouv.fr/), dispose d'une API que le programme peut interroger, les données étant placées sous [licence ouverte 2.0](https://www.etalab.gouv.fr/wp-content/uploads/2017/04/ETALAB-Licence-Ouverte-v2.0.pdf).
25 |
26 | Interroger Légifrance suppose une authentification préalable à l'aide d'identifiants personnels. La [version accessible à tous de code is low](codeislow.enetter.fr) utilise les identifiants du développeur. Exécuter le programme par vos propres moyens implique l'obtention d'identifiants Légifrance (voir plus bas).
27 |
28 | Au moment de l'authentification, Légifrance accorde un jeton valable une heure seulement, et qui devra être présenté à chaque requête. Le programme est donc conçu pour demander un nouveau jeton à chaque utilisation.
29 |
30 | Pour chaque article de code, son identifiant est récupéré à l'aide d'une première requête. Si l'article existe (il n'y a pas d'erreur dans sa référence et il n'a pas été abrogé), une seconde requête permet de récupérer un vaste ensemble d'informations. On y récupère la date à laquelle a débuté la version de l'article actuellement en vigueur et, le cas échéant, la date à laquelle elle deviendra obsolète (abrogation avec effet différé, remplacement par une nouvelle version).
31 |
32 | ## Tri et affichage des résultats
33 |
34 | Les articles n'ayant pas renvoyé d'identifiant unique sont placés dans une liste de textes non trouvés.
35 |
36 | Pour les autres, la date de début et la date de fin de version d'article sont confrontées avec les périodes définies par l'utilisateur dans le formulaire initial. En fonction du résultat, l'article peut être classé comme ayant connu une version passée dans la période de référence pour le passé ET comme ayant vocation à changer dans la période de référence pour le futur. S'il n'a ni été modifié dans la période passée ni ne sera modifié dans la période future, il est classé dans la catégorie des articles correctements détectés mais ne présentant pas d'événement.
37 |
38 | A partir de ces différentes listes, une page de résultats est générée dynamiquement. Hormis les articles non trouvés, les textes sont cliquables et le lien conduit vers leur version sur Légifrance. Le lien est construit à partir d'une racine commune suivie de l'identifiant unique rapatrié au moment de la première requête.
39 |
40 | ## Exécuter le programme localement
41 |
42 | Une version du programme utilisable par tous est mise à disposition sur un serveur Heroku. Cela permet à l'utilisateur de profiter des identifiants du développeur sans qu'ils soient révélés.
43 |
44 | En dépit des précautions employées (connexion forcée en HTTPS, fichier supprimé avant la fin du script), il est déconseillé de soumettre à la version collective des fichiers contenant des données sensibles, confidentielles ou soumises à un secret professionnel. Le programme peut être exécuté sur votre machine et générera une page web identique purement locale. Seules les requêtes Légifrance sortiront vers l'extérieur. Cette solution requiert l'installation de Python, le clonage ou le téléchargement du dépôt Github, et [l'obtention d'identifiants pour l'API auprès de PISTE](https://developer.aife.economie.gouv.fr/).
45 |
46 | Il vous faudra alors créer un fichier intitulé .env, que vous placerez dans le même répertoire que le script codeislow.py, avec le contenu ci-dessous, en remplaçant évidemment "XXXX" par les valeurs qui vous auront été fournies par PISTE.
47 |
48 | CLIENT_ID = XXXX
49 | CLIENT_SECRET = XXXX
50 | si la version en cours de code is low utilise encore un mot de passe, vous devrez ajouter un champ PASSWORD = et y placer la valeur de votre choix.
51 |
52 |
--------------------------------------------------------------------------------
/app.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python3
2 | # coding: utf-8
3 | #filename: app.py
4 | """
5 | Main Bottle app
6 |
7 | """
8 | import os
9 | import json
10 |
11 | from bottle import Bottle
12 | from bottle import request, static_file
13 | from jinja2 import Environment, FileSystemLoader
14 | from code_references import CODE_REFERENCE, CODE_REGEX
15 | from codeislow import main, load_result
16 | from result_templates import start_results, end_results
17 |
18 | app = Bottle()
19 |
20 | environment = Environment(loader=FileSystemLoader("templates/"))
21 |
22 | @app.route("/")
23 | def home():
24 | template = environment.get_template("home.html")
25 | return template.render(code_names=list(CODE_REFERENCE.items()))
26 |
27 |
28 | @app.route("/cgu/")
29 | def cgu():
30 | template = environment.get_template("cgu.html")
31 | return template.render()
32 |
33 | @app.route("/about/")
34 | def about():
35 | template = environment.get_template("about.html")
36 | return template.render()
37 |
38 | @app.route("/codes/")
39 | def codes():
40 | code_full_list = []
41 | for short_code, long_code in CODE_REFERENCE.items():
42 | regex_c = CODE_REGEX[short_code]
43 | regex = f"{regex_c}"
44 | comment = """?"""
45 | code_full_list.append((long_code, short_code, regex, comment))
46 | template = environment.get_template("codes.html")
47 | return template.render(codes_full_list=code_full_list)
48 |
49 | # @app.route('/ajax')
50 | # def ajax():
51 | # template = environment.get_template("results.html")
52 | # return template.render('results.html',
53 | # result=result)
54 | #https://stackoverflow.com/questions/69125397/call-function-with-arguments-from-user-input-in-python3-flask-jinja2-template
55 | #https://stackoverflow.com/questions/6036082/call-a-python-function-from-jinja2
56 |
57 | @app.route("/upload/", method="POST")
58 | def upload():
59 | upload = request.files.get('upload')
60 | name, ext = os.path.splitext(upload.filename)
61 |
62 | if ext not in ('.doc','.docx','.odt', '.pdf'):
63 | return 'Le format du fichier est incorrect'
64 | file_path = os.path.join("tmp", upload.filename)
65 | upload.save(file_path)
66 | past = int(request.forms.get('user_past'))
67 | future = int(request.forms.get('user_future'))
68 | selected_codes = [short_name for short_name in CODE_REFERENCE.keys() if request.forms.get(short_name) is not None]
69 | if len(selected_codes) == 0:
70 | selected_codes = None
71 | yield start_results
72 | for row in load_result(file_path, None, "article_code", past, future):
73 | yield row
74 | # row = f'''
75 | #
Le développeur propose, à titre gracieux et non-professionnel, un outil
62 | expérimental d'aide au traitement de textes juridiques. Il décline toute
63 | responsabilité pour le cas où les références à des articles de codes de droit français ne seraient
64 | pas correctement détectées. La responsabilité de l'exactitude des informations figurant sur la base
65 | de données Légifrance relève, quant à elle,
66 | exclusivement de la DILA. Pour le surplus,
67 | l'utilisation de ce logiciel est soumise à la licence CeCILL.
69 |
70 |
71 |
Politique de confidentialité
72 |
73 |
74 |
75 |
L'application web est proposée par E. Netter, à titre individuel, sans impliquer l'université à
76 | laquelle il appartient. E. Netter est responsable du traitement des données à caractère personnel
77 | que vos documents pourraient contenir, au sens du règlement général sur la protection des
79 | données et de la loi
80 | informatique et libertés. Le serveur est opéré par Heroku, qui occupe une position de sous-traitant des données,
82 | rémunéré par E. Netter. Vos données sont traitées sur le fondement de la nécessité pour l'exécution
83 | d'une prestation de service dont vous demandez à bénéficier (art. 6,
85 | 1, b RGPD).
86 |
87 |
88 |
Conformément au code
89 | source public, votre document est copié dans un fichier provisoire uniquement le temps
90 | d'être traité, puis supprimé (ligne "os.remove") avant même l'affichage des résultats. Au cas où la
91 | suppression échouerait en raison d'un bug, les fichiers sont automatiquement détruits par Heroku
92 | toutes les 24h, et le développeur s'engage à ne pas en prendre connaissance. Si vous souhaitez
93 | cependant qu'il examine votre document afin de comprendre pourquoi un examen a échoué, vous pouvez
94 | choisir de lui adresser, à l'adresse email située en haut de page. Il s'engage alors à ne
95 | l'exploiter à aucune autre fin puis à la détruire. L'échange entre votre navigateur et le serveur
96 | doit être chiffré. Si votre navigateur présente un cadenas ouvert ou indique que la connexion n'est
97 | pas sécurisée, il s'agit d'un dysfonctionnement et l'outil ne devrait pas être utilisé.
98 |
99 |
Il est également possible de préférer à cette application web une exécution locale du code source sur votre propre système
101 | informatique. C'est le mode vivement recommandé pour le cas où votre document contiendrait des
102 | données confidentielles, particulièrement sensibles, ou soumises au secret professionnel.
103 | Rapprochez-vous de la personne responsable de vos systèmes d'information. L'ouverture d'un compte développeur PISTE (rapide et
105 | gratuite) sera alors nécessaire.
106 |
107 |
Les droits qui vous sont reconnus par le RGPD et la LIL vous
109 | sont présentés par l'auteur sur son site de chercheur en droit.
110 |
111 |
Si vous estimez que vos droits ont été méconnus, je vous invite à me contacter avant toute autre
112 | démarche, à l'adresse email figurant en haut de la page. Vous disposez du droit de déposer une
113 | réclamation auprès de la
114 | CNIL.
115 |
116 |
117 |
118 |
119 |
120 |
121 |
--------------------------------------------------------------------------------
/check_validity.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python3
2 | # coding: utf-8
3 | # filename: check_validity.py
4 | """
5 |
6 | Module de vérification du status de l'article
7 |
8 | - multiple time_converters:
9 | - (date <-> datetime)
10 | - (date,datetime <-> str)
11 | - (epoch<-> datetime)
12 | - time_delta: définition de nouvelle dates à partir d'un nombre année
13 | - check validity: module qui définit le status de l'article en fonction d'une plage temporelle
14 |
15 | """
16 | from datetime import datetime
17 | import datetime
18 | from dateutil.relativedelta import relativedelta
19 |
20 |
21 |
22 | ### TIME CONVERSION UTILS
23 |
24 | def convert_date_to_datetime(date):
25 | return datetime.datetime.fromordinal(date.toordinal())
26 |
27 |
28 | def convert_datetime_to_date(date_time):
29 | date_time.replace(hour=0, minute=0, second=0)
30 | return date_time
31 |
32 |
33 | def convert_epoch_to_datetime(epoch):
34 | """convert epoch (seconds till 01/01/1970) to date"""
35 | return datetime.datetime.utcfromtimestamp(epoch / 1000)
36 |
37 |
38 | def convert_datetime_to_epoch(date_time):
39 | """convert datetime to epoch"""
40 | epoch = datetime.datetime.utcfromtimestamp(0)
41 | # return date_time - epoch
42 | return (date_time - epoch).total_seconds() * 1000
43 |
44 |
45 | def convert_date_to_str(date_time):
46 | """convert datetime into string format"""
47 | return datetime.datetime.strftime(date_time[:4], "%d/%m/%Y")
48 |
49 |
50 | def convert_datetime_to_str(date_time):
51 | """convert datetime into string format"""
52 | return datetime.datetime.strftime(date_time, "%d/%m/%Y %H:%M:%S")
53 |
54 |
55 | def convert_str_to_datetime(date_time):
56 | '''
57 | convert string format into datetime
58 | Arguments:
59 | date_str: string representation of a date
60 | Returns:
61 | date_time: datetime
62 | '''
63 | return datetime.datetime.strptime(date_time, "%d/%m/%Y %H:%M:%S")
64 |
65 | ### SPECIALS: plage de temps + status de l'article
66 | def time_delta(operator, year_nb):
67 | """
68 | Calculer le différentiel de date selon l'opérator et le nombre d'années
69 | Arguments
70 | ----------
71 | operator: str
72 | chaine de caractère qui représente l'opérateur: - ou +
73 | year_nb: int
74 | entier qui représente le nombre d'années
75 | Return
76 | -------
77 | datetime_delta: datetime
78 | objet datetime représentant la nouvelle date
79 | """
80 | if operator not in ["-", "+"]:
81 | raise ValueError("Wrong operator")
82 | if not isinstance(year_nb, int):
83 | raise TypeError("Year must be an integer")
84 | today = datetime.date.today()
85 | if operator == "-":
86 | return convert_date_to_datetime(today.replace(year=today.year - year_nb))
87 | else:
88 | return convert_date_to_datetime(today.replace(year=today.year + year_nb))
89 |
90 |
91 | def time_delta_to_epoch(operator, year_nb):
92 | """
93 | Calculer le différentiel de date selon l'opérator et le nombre d'années
94 |
95 | Arguments
96 | ----------
97 | operator: str
98 | chaine de caractère qui représente l'opérateur: - ou +
99 | year_nb: int
100 | entier qui représente le nombre d'années
101 | Return
102 | -------
103 | epoch_delta: int
104 | timestamp/epoch représentant la nouvelle date
105 | """
106 |
107 |
108 | return convert_datetime_to_epoch(time_delta(operator, year_nb))
109 |
110 | def get_validity_status(start, end, year_before, year_after):
111 | """
112 | Verifier la validité de l'article à partir d'une plage de temps
113 |
114 | Arguments
115 | ---------
116 | year_before: int
117 | Nombre d'année avant aujourd'hui
118 | start: datetime
119 | Date de création de l'article
120 | year_after:int
121 | Nombre d'année après aujourd'hui
122 | end: datetime
123 | Date d'expiration de l'article
124 |
125 | Returns
126 | --------
127 | status_code: int
128 | Un code de status qui s'inspire d'HTTP
129 | response: str
130 | Un message de status
131 | color: str
132 | Couleur CSS du status: green, yellow, orange, red
133 | """
134 | past_boundary = time_delta("-", year_before)
135 | future_boundary = time_delta("+", year_after)
136 | if start > past_boundary:
137 | return (301, "Modifié le {}".format(convert_datetime_to_str(start).split(" ")[0]), "yellow")
138 | if end < future_boundary:
139 | return (302, "Valable jusqu'au {}".format(convert_datetime_to_str(end).split(" ")[0]), "orange")
140 | if start < past_boundary and end > future_boundary:
141 | return (204, "Pas de modification", "green")
142 |
143 |
--------------------------------------------------------------------------------
/code_list.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Code is low - Liste des codes
5 |
6 |
7 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
60 | """
61 | yield(row)
62 |
63 |
64 |
65 |
--------------------------------------------------------------------------------
/docs/Licence_CeCILL_V2.1-fr.txt:
--------------------------------------------------------------------------------
1 |
2 | CONTRAT DE LICENCE DE LOGICIEL LIBRE CeCILL
3 |
4 | Version 2.1 du 2013-06-21
5 |
6 |
7 | Avertissement
8 |
9 | Ce contrat est une licence de logiciel libre issue d'une concertation
10 | entre ses auteurs afin que le respect de deux grands principes préside à
11 | sa rédaction:
12 |
13 | * d'une part, le respect des principes de diffusion des logiciels
14 | libres: accès au code source, droits étendus conférés aux utilisateurs,
15 | * d'autre part, la désignation d'un droit applicable, le droit
16 | français, auquel elle est conforme, tant au regard du droit de la
17 | responsabilité civile que du droit de la propriété intellectuelle et
18 | de la protection qu'il offre aux auteurs et titulaires des droits
19 | patrimoniaux sur un logiciel.
20 |
21 | Les auteurs de la licence CeCILL (Ce[a] C[nrs] I[nria] L[ogiciel] L[ibre])
22 | sont:
23 |
24 | Commissariat à l'énergie atomique et aux énergies alternatives - CEA,
25 | établissement public de recherche à caractère scientifique, technique et
26 | industriel, dont le siège est situé 25 rue Leblanc, immeuble Le Ponant
27 | D, 75015 Paris.
28 |
29 | Centre National de la Recherche Scientifique - CNRS, établissement
30 | public à caractère scientifique et technologique, dont le siège est
31 | situé 3 rue Michel-Ange, 75794 Paris cedex 16.
32 |
33 | Institut National de Recherche en Informatique et en Automatique -
34 | Inria, établissement public à caractère scientifique et technologique,
35 | dont le siège est situé Domaine de Voluceau, Rocquencourt, BP 105, 78153
36 | Le Chesnay cedex.
37 |
38 |
39 | Préambule
40 |
41 | Ce contrat est une licence de logiciel libre dont l'objectif est de
42 | conférer aux utilisateurs la liberté de modification et de
43 | redistribution du logiciel régi par cette licence dans le cadre d'un
44 | modèle de diffusion en logiciel libre.
45 |
46 | L'exercice de ces libertés est assorti de certains devoirs à la charge
47 | des utilisateurs afin de préserver ce statut au cours des
48 | redistributions ultérieures.
49 |
50 | L'accessibilité au code source et les droits de copie, de modification
51 | et de redistribution qui en découlent ont pour contrepartie de n'offrir
52 | aux utilisateurs qu'une garantie limitée et de ne faire peser sur
53 | l'auteur du logiciel, le titulaire des droits patrimoniaux et les
54 | concédants successifs qu'une responsabilité restreinte.
55 |
56 | A cet égard l'attention de l'utilisateur est attirée sur les risques
57 | associés au chargement, à l'utilisation, à la modification et/ou au
58 | développement et à la reproduction du logiciel par l'utilisateur étant
59 | donné sa spécificité de logiciel libre, qui peut le rendre complexe à
60 | manipuler et qui le réserve donc à des développeurs ou des
61 | professionnels avertis possédant des connaissances informatiques
62 | approfondies. Les utilisateurs sont donc invités à charger et tester
63 | l'adéquation du logiciel à leurs besoins dans des conditions permettant
64 | d'assurer la sécurité de leurs systèmes et/ou de leurs données et, plus
65 | généralement, à l'utiliser et l'exploiter dans les mêmes conditions de
66 | sécurité. Ce contrat peut être reproduit et diffusé librement, sous
67 | réserve de le conserver en l'état, sans ajout ni suppression de clauses.
68 |
69 | Ce contrat est susceptible de s'appliquer à tout logiciel dont le
70 | titulaire des droits patrimoniaux décide de soumettre l'exploitation aux
71 | dispositions qu'il contient.
72 |
73 | Une liste de questions fréquemment posées se trouve sur le site web
74 | officiel de la famille des licences CeCILL
75 | (http://www.cecill.info/index.fr.html) pour toute clarification qui
76 | serait nécessaire.
77 |
78 |
79 | Article 1 - DEFINITIONS
80 |
81 | Dans ce contrat, les termes suivants, lorsqu'ils seront écrits avec une
82 | lettre capitale, auront la signification suivante:
83 |
84 | Contrat: désigne le présent contrat de licence, ses éventuelles versions
85 | postérieures et annexes.
86 |
87 | Logiciel: désigne le logiciel sous sa forme de Code Objet et/ou de Code
88 | Source et le cas échéant sa documentation, dans leur état au moment de
89 | l'acceptation du Contrat par le Licencié.
90 |
91 | Logiciel Initial: désigne le Logiciel sous sa forme de Code Source et
92 | éventuellement de Code Objet et le cas échéant sa documentation, dans
93 | leur état au moment de leur première diffusion sous les termes du Contrat.
94 |
95 | Logiciel Modifié: désigne le Logiciel modifié par au moins une
96 | Contribution.
97 |
98 | Code Source: désigne l'ensemble des instructions et des lignes de
99 | programme du Logiciel et auquel l'accès est nécessaire en vue de
100 | modifier le Logiciel.
101 |
102 | Code Objet: désigne les fichiers binaires issus de la compilation du
103 | Code Source.
104 |
105 | Titulaire: désigne le ou les détenteurs des droits patrimoniaux d'auteur
106 | sur le Logiciel Initial.
107 |
108 | Licencié: désigne le ou les utilisateurs du Logiciel ayant accepté le
109 | Contrat.
110 |
111 | Contributeur: désigne le Licencié auteur d'au moins une Contribution.
112 |
113 | Concédant: désigne le Titulaire ou toute personne physique ou morale
114 | distribuant le Logiciel sous le Contrat.
115 |
116 | Contribution: désigne l'ensemble des modifications, corrections,
117 | traductions, adaptations et/ou nouvelles fonctionnalités intégrées dans
118 | le Logiciel par tout Contributeur, ainsi que tout Module Interne.
119 |
120 | Module: désigne un ensemble de fichiers sources y compris leur
121 | documentation qui permet de réaliser des fonctionnalités ou services
122 | supplémentaires à ceux fournis par le Logiciel.
123 |
124 | Module Externe: désigne tout Module, non dérivé du Logiciel, tel que ce
125 | Module et le Logiciel s'exécutent dans des espaces d'adressage
126 | différents, l'un appelant l'autre au moment de leur exécution.
127 |
128 | Module Interne: désigne tout Module lié au Logiciel de telle sorte
129 | qu'ils s'exécutent dans le même espace d'adressage.
130 |
131 | GNU GPL: désigne la GNU General Public License dans sa version 2 ou
132 | toute version ultérieure, telle que publiée par Free Software Foundation
133 | Inc.
134 |
135 | GNU Affero GPL: désigne la GNU Affero General Public License dans sa
136 | version 3 ou toute version ultérieure, telle que publiée par Free
137 | Software Foundation Inc.
138 |
139 | EUPL: désigne la Licence Publique de l'Union européenne dans sa version
140 | 1.1 ou toute version ultérieure, telle que publiée par la Commission
141 | Européenne.
142 |
143 | Parties: désigne collectivement le Licencié et le Concédant.
144 |
145 | Ces termes s'entendent au singulier comme au pluriel.
146 |
147 |
148 | Article 2 - OBJET
149 |
150 | Le Contrat a pour objet la concession par le Concédant au Licencié d'une
151 | licence non exclusive, cessible et mondiale du Logiciel telle que
152 | définie ci-après à l'article 5 <#etendue> pour toute la durée de
153 | protection des droits portant sur ce Logiciel.
154 |
155 |
156 | Article 3 - ACCEPTATION
157 |
158 | 3.1 L'acceptation par le Licencié des termes du Contrat est réputée
159 | acquise du fait du premier des faits suivants:
160 |
161 | * (i) le chargement du Logiciel par tout moyen notamment par
162 | téléchargement à partir d'un serveur distant ou par chargement à
163 | partir d'un support physique;
164 | * (ii) le premier exercice par le Licencié de l'un quelconque des
165 | droits concédés par le Contrat.
166 |
167 | 3.2 Un exemplaire du Contrat, contenant notamment un avertissement
168 | relatif aux spécificités du Logiciel, à la restriction de garantie et à
169 | la limitation à un usage par des utilisateurs expérimentés a été mis à
170 | disposition du Licencié préalablement à son acceptation telle que
171 | définie à l'article 3.1 <#acceptation-acquise> ci dessus et le Licencié
172 | reconnaît en avoir pris connaissance.
173 |
174 |
175 | Article 4 - ENTREE EN VIGUEUR ET DUREE
176 |
177 |
178 | 4.1 ENTREE EN VIGUEUR
179 |
180 | Le Contrat entre en vigueur à la date de son acceptation par le Licencié
181 | telle que définie en 3.1 <#acceptation-acquise>.
182 |
183 |
184 | 4.2 DUREE
185 |
186 | Le Contrat produira ses effets pendant toute la durée légale de
187 | protection des droits patrimoniaux portant sur le Logiciel.
188 |
189 |
190 | Article 5 - ETENDUE DES DROITS CONCEDES
191 |
192 | Le Concédant concède au Licencié, qui accepte, les droits suivants sur
193 | le Logiciel pour toutes destinations et pour la durée du Contrat dans
194 | les conditions ci-après détaillées.
195 |
196 | Par ailleurs, si le Concédant détient ou venait à détenir un ou
197 | plusieurs brevets d'invention protégeant tout ou partie des
198 | fonctionnalités du Logiciel ou de ses composants, il s'engage à ne pas
199 | opposer les éventuels droits conférés par ces brevets aux Licenciés
200 | successifs qui utiliseraient, exploiteraient ou modifieraient le
201 | Logiciel. En cas de cession de ces brevets, le Concédant s'engage à
202 | faire reprendre les obligations du présent alinéa aux cessionnaires.
203 |
204 |
205 | 5.1 DROIT D'UTILISATION
206 |
207 | Le Licencié est autorisé à utiliser le Logiciel, sans restriction quant
208 | aux domaines d'application, étant ci-après précisé que cela comporte:
209 |
210 | 1.
211 |
212 | la reproduction permanente ou provisoire du Logiciel en tout ou
213 | partie par tout moyen et sous toute forme.
214 |
215 | 2.
216 |
217 | le chargement, l'affichage, l'exécution, ou le stockage du Logiciel
218 | sur tout support.
219 |
220 | 3.
221 |
222 | la possibilité d'en observer, d'en étudier, ou d'en tester le
223 | fonctionnement afin de déterminer les idées et principes qui sont à
224 | la base de n'importe quel élément de ce Logiciel; et ceci, lorsque
225 | le Licencié effectue toute opération de chargement, d'affichage,
226 | d'exécution, de transmission ou de stockage du Logiciel qu'il est en
227 | droit d'effectuer en vertu du Contrat.
228 |
229 |
230 | 5.2 DROIT D'APPORTER DES CONTRIBUTIONS
231 |
232 | Le droit d'apporter des Contributions comporte le droit de traduire,
233 | d'adapter, d'arranger ou d'apporter toute autre modification au Logiciel
234 | et le droit de reproduire le logiciel en résultant.
235 |
236 | Le Licencié est autorisé à apporter toute Contribution au Logiciel sous
237 | réserve de mentionner, de façon explicite, son nom en tant qu'auteur de
238 | cette Contribution et la date de création de celle-ci.
239 |
240 |
241 | 5.3 DROIT DE DISTRIBUTION
242 |
243 | Le droit de distribution comporte notamment le droit de diffuser, de
244 | transmettre et de communiquer le Logiciel au public sur tout support et
245 | par tout moyen ainsi que le droit de mettre sur le marché à titre
246 | onéreux ou gratuit, un ou des exemplaires du Logiciel par tout procédé.
247 |
248 | Le Licencié est autorisé à distribuer des copies du Logiciel, modifié ou
249 | non, à des tiers dans les conditions ci-après détaillées.
250 |
251 |
252 | 5.3.1 DISTRIBUTION DU LOGICIEL SANS MODIFICATION
253 |
254 | Le Licencié est autorisé à distribuer des copies conformes du Logiciel,
255 | sous forme de Code Source ou de Code Objet, à condition que cette
256 | distribution respecte les dispositions du Contrat dans leur totalité et
257 | soit accompagnée:
258 |
259 | 1.
260 |
261 | d'un exemplaire du Contrat,
262 |
263 | 2.
264 |
265 | d'un avertissement relatif à la restriction de garantie et de
266 | responsabilité du Concédant telle que prévue aux articles 8
267 | <#responsabilite> et 9 <#garantie>,
268 |
269 | et que, dans le cas où seul le Code Objet du Logiciel est redistribué,
270 | le Licencié permette un accès effectif au Code Source complet du
271 | Logiciel pour une durée d'au moins 3 ans à compter de la distribution du
272 | logiciel, étant entendu que le coût additionnel d'acquisition du Code
273 | Source ne devra pas excéder le simple coût de transfert des données.
274 |
275 |
276 | 5.3.2 DISTRIBUTION DU LOGICIEL MODIFIE
277 |
278 | Lorsque le Licencié apporte une Contribution au Logiciel, les conditions
279 | de distribution du Logiciel Modifié en résultant sont alors soumises à
280 | l'intégralité des dispositions du Contrat.
281 |
282 | Le Licencié est autorisé à distribuer le Logiciel Modifié, sous forme de
283 | code source ou de code objet, à condition que cette distribution
284 | respecte les dispositions du Contrat dans leur totalité et soit
285 | accompagnée:
286 |
287 | 1.
288 |
289 | d'un exemplaire du Contrat,
290 |
291 | 2.
292 |
293 | d'un avertissement relatif à la restriction de garantie et de
294 | responsabilité du Concédant telle que prévue aux articles 8
295 | <#responsabilite> et 9 <#garantie>,
296 |
297 | et, dans le cas où seul le code objet du Logiciel Modifié est redistribué,
298 |
299 | 3.
300 |
301 | d'une note précisant les conditions d'accès effectif au code source
302 | complet du Logiciel Modifié, pendant une période d'au moins 3 ans à
303 | compter de la distribution du Logiciel Modifié, étant entendu que le
304 | coût additionnel d'acquisition du code source ne devra pas excéder
305 | le simple coût de transfert des données.
306 |
307 |
308 | 5.3.3 DISTRIBUTION DES MODULES EXTERNES
309 |
310 | Lorsque le Licencié a développé un Module Externe les conditions du
311 | Contrat ne s'appliquent pas à ce Module Externe, qui peut être distribué
312 | sous un contrat de licence différent.
313 |
314 |
315 | 5.3.4 COMPATIBILITE AVEC D'AUTRES LICENCES
316 |
317 | Le Licencié peut inclure un code soumis aux dispositions d'une des
318 | versions de la licence GNU GPL, GNU Affero GPL et/ou EUPL dans le
319 | Logiciel modifié ou non et distribuer l'ensemble sous les conditions de
320 | la même version de la licence GNU GPL, GNU Affero GPL et/ou EUPL.
321 |
322 | Le Licencié peut inclure le Logiciel modifié ou non dans un code soumis
323 | aux dispositions d'une des versions de la licence GNU GPL, GNU Affero
324 | GPL et/ou EUPL et distribuer l'ensemble sous les conditions de la même
325 | version de la licence GNU GPL, GNU Affero GPL et/ou EUPL.
326 |
327 |
328 | Article 6 - PROPRIETE INTELLECTUELLE
329 |
330 |
331 | 6.1 SUR LE LOGICIEL INITIAL
332 |
333 | Le Titulaire est détenteur des droits patrimoniaux sur le Logiciel
334 | Initial. Toute utilisation du Logiciel Initial est soumise au respect
335 | des conditions dans lesquelles le Titulaire a choisi de diffuser son
336 | oeuvre et nul autre n'a la faculté de modifier les conditions de
337 | diffusion de ce Logiciel Initial.
338 |
339 | Le Titulaire s'engage à ce que le Logiciel Initial reste au moins régi
340 | par le Contrat et ce, pour la durée visée à l'article 4.2 <#duree>.
341 |
342 |
343 | 6.2 SUR LES CONTRIBUTIONS
344 |
345 | Le Licencié qui a développé une Contribution est titulaire sur celle-ci
346 | des droits de propriété intellectuelle dans les conditions définies par
347 | la législation applicable.
348 |
349 |
350 | 6.3 SUR LES MODULES EXTERNES
351 |
352 | Le Licencié qui a développé un Module Externe est titulaire sur celui-ci
353 | des droits de propriété intellectuelle dans les conditions définies par
354 | la législation applicable et reste libre du choix du contrat régissant
355 | sa diffusion.
356 |
357 |
358 | 6.4 DISPOSITIONS COMMUNES
359 |
360 | Le Licencié s'engage expressément:
361 |
362 | 1.
363 |
364 | à ne pas supprimer ou modifier de quelque manière que ce soit les
365 | mentions de propriété intellectuelle apposées sur le Logiciel;
366 |
367 | 2.
368 |
369 | à reproduire à l'identique lesdites mentions de propriété
370 | intellectuelle sur les copies du Logiciel modifié ou non.
371 |
372 | Le Licencié s'engage à ne pas porter atteinte, directement ou
373 | indirectement, aux droits de propriété intellectuelle du Titulaire et/ou
374 | des Contributeurs sur le Logiciel et à prendre, le cas échéant, à
375 | l'égard de son personnel toutes les mesures nécessaires pour assurer le
376 | respect des dits droits de propriété intellectuelle du Titulaire et/ou
377 | des Contributeurs.
378 |
379 |
380 | Article 7 - SERVICES ASSOCIES
381 |
382 | 7.1 Le Contrat n'oblige en aucun cas le Concédant à la réalisation de
383 | prestations d'assistance technique ou de maintenance du Logiciel.
384 |
385 | Cependant le Concédant reste libre de proposer ce type de services. Les
386 | termes et conditions d'une telle assistance technique et/ou d'une telle
387 | maintenance seront alors déterminés dans un acte séparé. Ces actes de
388 | maintenance et/ou assistance technique n'engageront que la seule
389 | responsabilité du Concédant qui les propose.
390 |
391 | 7.2 De même, tout Concédant est libre de proposer, sous sa seule
392 | responsabilité, à ses licenciés une garantie, qui n'engagera que lui,
393 | lors de la redistribution du Logiciel et/ou du Logiciel Modifié et ce,
394 | dans les conditions qu'il souhaite. Cette garantie et les modalités
395 | financières de son application feront l'objet d'un acte séparé entre le
396 | Concédant et le Licencié.
397 |
398 |
399 | Article 8 - RESPONSABILITE
400 |
401 | 8.1 Sous réserve des dispositions de l'article 8.2
402 | <#limite-responsabilite>, le Licencié a la faculté, sous réserve de
403 | prouver la faute du Concédant concerné, de solliciter la réparation du
404 | préjudice direct qu'il subirait du fait du Logiciel et dont il apportera
405 | la preuve.
406 |
407 | 8.2 La responsabilité du Concédant est limitée aux engagements pris en
408 | application du Contrat et ne saurait être engagée en raison notamment:
409 | (i) des dommages dus à l'inexécution, totale ou partielle, de ses
410 | obligations par le Licencié, (ii) des dommages directs ou indirects
411 | découlant de l'utilisation ou des performances du Logiciel subis par le
412 | Licencié et (iii) plus généralement d'un quelconque dommage indirect. En
413 | particulier, les Parties conviennent expressément que tout préjudice
414 | financier ou commercial (par exemple perte de données, perte de
415 | bénéfices, perte d'exploitation, perte de clientèle ou de commandes,
416 | manque à gagner, trouble commercial quelconque) ou toute action dirigée
417 | contre le Licencié par un tiers, constitue un dommage indirect et
418 | n'ouvre pas droit à réparation par le Concédant.
419 |
420 |
421 | Article 9 - GARANTIE
422 |
423 | 9.1 Le Licencié reconnaît que l'état actuel des connaissances
424 | scientifiques et techniques au moment de la mise en circulation du
425 | Logiciel ne permet pas d'en tester et d'en vérifier toutes les
426 | utilisations ni de détecter l'existence d'éventuels défauts. L'attention
427 | du Licencié a été attirée sur ce point sur les risques associés au
428 | chargement, à l'utilisation, la modification et/ou au développement et à
429 | la reproduction du Logiciel qui sont réservés à des utilisateurs avertis.
430 |
431 | Il relève de la responsabilité du Licencié de contrôler, par tous
432 | moyens, l'adéquation du produit à ses besoins, son bon fonctionnement et
433 | de s'assurer qu'il ne causera pas de dommages aux personnes et aux biens.
434 |
435 | 9.2 Le Concédant déclare de bonne foi être en droit de concéder
436 | l'ensemble des droits attachés au Logiciel (comprenant notamment les
437 | droits visés à l'article 5 <#etendue>).
438 |
439 | 9.3 Le Licencié reconnaît que le Logiciel est fourni "en l'état" par le
440 | Concédant sans autre garantie, expresse ou tacite, que celle prévue à
441 | l'article 9.2 <#bonne-foi> et notamment sans aucune garantie sur sa
442 | valeur commerciale, son caractère sécurisé, innovant ou pertinent.
443 |
444 | En particulier, le Concédant ne garantit pas que le Logiciel est exempt
445 | d'erreur, qu'il fonctionnera sans interruption, qu'il sera compatible
446 | avec l'équipement du Licencié et sa configuration logicielle ni qu'il
447 | remplira les besoins du Licencié.
448 |
449 | 9.4 Le Concédant ne garantit pas, de manière expresse ou tacite, que le
450 | Logiciel ne porte pas atteinte à un quelconque droit de propriété
451 | intellectuelle d'un tiers portant sur un brevet, un logiciel ou sur tout
452 | autre droit de propriété. Ainsi, le Concédant exclut toute garantie au
453 | profit du Licencié contre les actions en contrefaçon qui pourraient être
454 | diligentées au titre de l'utilisation, de la modification, et de la
455 | redistribution du Logiciel. Néanmoins, si de telles actions sont
456 | exercées contre le Licencié, le Concédant lui apportera son expertise
457 | technique et juridique pour sa défense. Cette expertise technique et
458 | juridique est déterminée au cas par cas entre le Concédant concerné et
459 | le Licencié dans le cadre d'un protocole d'accord. Le Concédant dégage
460 | toute responsabilité quant à l'utilisation de la dénomination du
461 | Logiciel par le Licencié. Aucune garantie n'est apportée quant à
462 | l'existence de droits antérieurs sur le nom du Logiciel et sur
463 | l'existence d'une marque.
464 |
465 |
466 | Article 10 - RESILIATION
467 |
468 | 10.1 En cas de manquement par le Licencié aux obligations mises à sa
469 | charge par le Contrat, le Concédant pourra résilier de plein droit le
470 | Contrat trente (30) jours après notification adressée au Licencié et
471 | restée sans effet.
472 |
473 | 10.2 Le Licencié dont le Contrat est résilié n'est plus autorisé à
474 | utiliser, modifier ou distribuer le Logiciel. Cependant, toutes les
475 | licences qu'il aura concédées antérieurement à la résiliation du Contrat
476 | resteront valides sous réserve qu'elles aient été effectuées en
477 | conformité avec le Contrat.
478 |
479 |
480 | Article 11 - DISPOSITIONS DIVERSES
481 |
482 |
483 | 11.1 CAUSE EXTERIEURE
484 |
485 | Aucune des Parties ne sera responsable d'un retard ou d'une défaillance
486 | d'exécution du Contrat qui serait dû à un cas de force majeure, un cas
487 | fortuit ou une cause extérieure, telle que, notamment, le mauvais
488 | fonctionnement ou les interruptions du réseau électrique ou de
489 | télécommunication, la paralysie du réseau liée à une attaque
490 | informatique, l'intervention des autorités gouvernementales, les
491 | catastrophes naturelles, les dégâts des eaux, les tremblements de terre,
492 | le feu, les explosions, les grèves et les conflits sociaux, l'état de
493 | guerre...
494 |
495 | 11.2 Le fait, par l'une ou l'autre des Parties, d'omettre en une ou
496 | plusieurs occasions de se prévaloir d'une ou plusieurs dispositions du
497 | Contrat, ne pourra en aucun cas impliquer renonciation par la Partie
498 | intéressée à s'en prévaloir ultérieurement.
499 |
500 | 11.3 Le Contrat annule et remplace toute convention antérieure, écrite
501 | ou orale, entre les Parties sur le même objet et constitue l'accord
502 | entier entre les Parties sur cet objet. Aucune addition ou modification
503 | aux termes du Contrat n'aura d'effet à l'égard des Parties à moins
504 | d'être faite par écrit et signée par leurs représentants dûment habilités.
505 |
506 | 11.4 Dans l'hypothèse où une ou plusieurs des dispositions du Contrat
507 | s'avèrerait contraire à une loi ou à un texte applicable, existants ou
508 | futurs, cette loi ou ce texte prévaudrait, et les Parties feraient les
509 | amendements nécessaires pour se conformer à cette loi ou à ce texte.
510 | Toutes les autres dispositions resteront en vigueur. De même, la
511 | nullité, pour quelque raison que ce soit, d'une des dispositions du
512 | Contrat ne saurait entraîner la nullité de l'ensemble du Contrat.
513 |
514 |
515 | 11.5 LANGUE
516 |
517 | Le Contrat est rédigé en langue française et en langue anglaise, ces
518 | deux versions faisant également foi.
519 |
520 |
521 | Article 12 - NOUVELLES VERSIONS DU CONTRAT
522 |
523 | 12.1 Toute personne est autorisée à copier et distribuer des copies de
524 | ce Contrat.
525 |
526 | 12.2 Afin d'en préserver la cohérence, le texte du Contrat est protégé
527 | et ne peut être modifié que par les auteurs de la licence, lesquels se
528 | réservent le droit de publier périodiquement des mises à jour ou de
529 | nouvelles versions du Contrat, qui posséderont chacune un numéro
530 | distinct. Ces versions ultérieures seront susceptibles de prendre en
531 | compte de nouvelles problématiques rencontrées par les logiciels libres.
532 |
533 | 12.3 Tout Logiciel diffusé sous une version donnée du Contrat ne pourra
534 | faire l'objet d'une diffusion ultérieure que sous la même version du
535 | Contrat ou une version postérieure, sous réserve des dispositions de
536 | l'article 5.3.4 <#compatibilite>.
537 |
538 |
539 | Article 13 - LOI APPLICABLE ET COMPETENCE TERRITORIALE
540 |
541 | 13.1 Le Contrat est régi par la loi française. Les Parties conviennent
542 | de tenter de régler à l'amiable les différends ou litiges qui
543 | viendraient à se produire par suite ou à l'occasion du Contrat.
544 |
545 | 13.2 A défaut d'accord amiable dans un délai de deux (2) mois à compter
546 | de leur survenance et sauf situation relevant d'une procédure d'urgence,
547 | les différends ou litiges seront portés par la Partie la plus diligente
548 | devant les Tribunaux compétents de Paris.
549 |
550 |
551 |
--------------------------------------------------------------------------------
/documentation.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | Code is low - Guide d'utilisation
7 |
8 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
Soumettez un texte au format DOCX ou ODT (de préférence) ou PDF .
41 | Actuellement, la taille du fichier est limitée à 2 Mo
42 |
Le format PDF n'est pas toujours lisible. Les résultats peuvent être faussés.
43 |
Le programme recherchera des références à des articles de code (ex : "art. 1240 C. civ.", "article L. 110-1 du Code de commerce"). Il interrogera Légifrance à propos des articles détectés. Vous saurez ainsi :
44 |
45 |
46 |
Si le texte est introuvable sur Légifrance (abrogé, faute de frappe...)
47 |
Si le texte a été récemment modifié (période définie par vous) (N.B. : seule la modification la plus récente est mentionnée)
48 |
Si le texte va être modifié prochainement (période définie par vous) N.B. : seule la version à venir la plus proche est mentionnée)
49 |
50 |
51 |
La page du dépôt sur Github contient un fichier readme plus détaillé.
52 |
53 |
54 |
55 |
58 |
59 |
60 |
Le développeur propose, à titre gracieux et non-professionnel, un outil expérimental d'aide au traitement de textes juridiques. Il décline toute responsabilité pour le cas où les références à des articles de codes de droit français ne seraient pas correctement détectées. La responsabilité de l'exactitude des informations figurant sur la base de données Légifrance relève, quant à elle, exclusivement de la DILA. Pour le surplus, l'utilisation de ce logiciel est soumise à la licence CeCILL.
61 |
62 |
63 |
66 |
67 |
68 |
69 |
L'application web est proposée par E. Netter, à titre individuel, sans impliquer l'université à laquelle il appartient. E. Netter est responsable du traitement des données à caractère personnel que vos documents pourraient contenir, au sens du règlement général sur la protection des données et de la loi informatique et libertés. Le serveur est opéré par Heroku, qui occupe une position de sous-traitant des données, rémunéré par E. Netter. Vos données sont traitées sur le fondement de la nécessité pour l'exécution d'une prestation de service dont vous demandez à bénéficier (art. 6, 1, b RGPD).
70 |
71 |
72 |
Conformément au code source public, votre document est copié dans un fichier provisoire uniquement le temps d'être traité, puis supprimé (ligne "os.remove") avant même l'affichage des résultats. Au cas où la suppression échouerait en raison d'un bug, les fichiers sont automatiquement détruits par Heroku toutes les 24h, et le développeur s'engage à ne pas en prendre connaissance. Si vous souhaitez cependant qu'il examine votre document afin de comprendre pourquoi un examen a échoué, vous pouvez choisir de lui adresser, à l'adresse email située en haut de page. Il s'engage alors à ne l'exploiter à aucune autre fin puis à la détruire. L'échange entre votre navigateur et le serveur doit être chiffré. Si votre navigateur présente un cadenas ouvert ou indique que la connexion n'est pas sécurisée, il s'agit d'un dysfonctionnement et l'outil ne devrait pas être utilisé.
73 |
74 |
Il est également possible de préférer à cette application web une exécution locale du code source sur votre propre système informatique. C'est le mode vivement recommandé pour le cas où votre document contiendrait des données confidentielles, particulièrement sensibles, ou soumises au secret professionnel. Rapprochez-vous de la personne responsable de vos systèmes d'information. L'ouverture d'un compte développeur PISTE (rapide et gratuite) sera alors nécessaire.
75 |
76 |
Les droits qui vous sont reconnus par le RGPD et la LIL vous sont présentés par l'auteur sur son site de chercheur en droit.
77 |
78 |
Si vous estimez que vos droits ont été méconnus, je vous invite à me contacter avant toute autre démarche, à l'adresse email figurant en haut de la page. Vous disposez du droit de déposer une réclamation auprès de la CNIL.
79 |
80 |
81 |
82 |
84 |
85 |
86 |
87 |
88 |
La forme longue est évidemment reconnue. La casse est indifférente. N'hésitez pas à demander l'ajout d'autres codes.
89 |
90 |
91 |
Code des assurances [C. assur.]
92 |
Code civil [C. civ.]
93 |
Code de commerce [C. com.]
94 |
Code de la consommation [C. conso.]
95 |
Code de l'entrée et du séjour des étrangers et du droit d'asile [CESEDA]
96 |
Code de l'environnement [C. envir., CE]
97 |
Code général des collectivités territoriales [CGCT]
98 |
Code de justice administrative [CJA]
99 |
Code pénal [C. pén.]
100 |
Code des postes et des communications électroniques [CPCE]
101 |
Code de procédure civile [C. pr. civ., CPC]
102 |
Code de procédure pénale [CPP]
103 |
Code de la propriété intellectuelle [C. pr. int., CPI]
104 |
Code de la santé publique [C. sant. pub., CSP]
105 |
Code de la sécurité intérieure [CSI]
106 |
Code de la sécurité sociale [CSS]
107 |
Code du travail [C. trav.]
108 |
109 |
110 |
111 |
112 |
122 |
123 |
124 |
125 |
126 |
127 |
--------------------------------------------------------------------------------
/matching.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python3
2 | #filename: matching.py
3 | """
4 | The matching module
5 |
6 | Ce module permet la detection des articles du code de droit français
7 |
8 | """
9 |
10 | import re
11 |
12 | from parsing import parse_doc
13 | from code_references import filter_code_regex, CODE_REFERENCE, CODE_REGEX
14 |
15 | ARTICLE_REGEX = r"(?P(Articles?|Art\.))"
16 |
17 | # ARTICLE_REF = re.compile("\d+")
18 | # ARTICLE_ID = r"(L|R|A|D)?(\.|\s)?\d+(-\d+)?((\s(al\.|alinea)?\s\d+)?(\s|\.)"
19 |
20 |
21 |
22 |
23 | def switch_pattern(selected_codes=None, pattern="article_code"):
24 | """
25 | Build pattern recognition using pattern short code switch
26 |
27 | Arguments
28 | ---------
29 | selected_codes: array
30 | a list of short codes to select. Default to None
31 | pattern: str
32 | a string article_code or code_article. Default to article_code
33 | Returns
34 | ---------
35 | regex_pattern: str
36 | a compiled regex pattern
37 | Raise
38 | --------
39 | ValueError:
40 | pattern name is wrong
41 | """
42 |
43 | code_regex = filter_code_regex(selected_codes)
44 |
45 | if pattern not in ["article_code", "code_article"]:
46 | raise ValueError(
47 | "Wrong pattern name: choose between 'article_code' or 'code_article'"
48 | )
49 | if pattern == "article_code":
50 | return re.compile(f"{ARTICLE_REGEX}(?P.*?){code_regex}", flags=re.I)
51 | # else:
52 | # #code_article
53 | # # return re.compile(f"{code_regex}.*?{ARTICLE_REGEX}(\s|\.)(?P.*?)(\.|\s)", flags=re.I)
54 | # return re.compile(f"{code_regex}.*?{ARTICLE_REGEX}.*?{ARTICLE_ID}", flags=re.I)
55 |
56 | def get_matching_results_dict(full_text, selected_short_codes=[], pattern_format="article_code"):
57 | """
58 | Une fonction qui renvoie un dictionnaire de resultats: trié par code (version abbréviée) avec la liste des articles détectés lui appartenant.
59 |
60 | Arguments
61 | ----------
62 | full_text: str
63 | a string of the full document normalized
64 | pattern_format: str
65 | a string representing the pattern format article_code or code_article. Defaut to article_code
66 |
67 | Returns
68 | ----------
69 | code_found: dict
70 | a dict compose of short version of code as key and list of the detected articles references as values {code: [art_ref, art_ref2, ... ]}
71 | """
72 | article_pattern = switch_pattern(selected_short_codes, pattern_format)
73 | code_found = {}
74 |
75 | # normalisation
76 | full_text = re.sub(r"\r|\n|\t|\xa0", " ", " ".join(full_text))
77 | for i, match in enumerate(re.finditer(article_pattern, full_text)):
78 | needle = match.groupdict()
79 | qualified_needle = {
80 | key: value for key, value in needle.items() if value is not None
81 | }
82 | msg = f"#{i+1}\t{qualified_needle}"
83 | # logging.debug(msg)
84 | # get the code shortname based on regex group name
85 | code = [k for k in qualified_needle.keys() if k not in ["ref", "art"]][0]
86 |
87 | ref = match.group("ref").strip()
88 | # split multiple articles of a same code
89 | refs = [
90 | n
91 | for n in re.split(r"(\set\s|,\s|\sdu)", ref)
92 | if n not in [" et ", ", ", " du", " ", ""]
93 | ]
94 | # normalize articles to remove dots, spaces, caret and 'alinea'
95 | refs = [
96 | "-".join(
97 | [
98 | r
99 | for r in re.split(r"\s|\.|-", ref)
100 | if r not in [" ", "", "al", "alinea", "alinéa"]
101 | ]
102 | )
103 | for ref in refs
104 | ]
105 | # clean caracters for everything but numbers and (L|A|R|D) and caret
106 | normalized_refs = []
107 | for ref in refs:
108 | # accepted caracters for article
109 | ref = "".join(
110 | [n for n in ref if (n.isdigit() or n in ["L", "A", "R", "D", "-"])]
111 | )
112 | if ref.endswith("-"):
113 | ref = ref[:-1]
114 | # remove caret separating article nb between first letter
115 | special_ref = ref.split("-", 1)
116 | if special_ref[0] in ["L", "A", "R", "D"]:
117 | normalized_refs.append("".join(special_ref))
118 | else:
119 | normalized_refs.append(ref)
120 |
121 | if code not in code_found:
122 | # append article references
123 | code_found[code] = normalized_refs
124 | else:
125 | # append article references to existing list
126 | code_found[code].extend(normalized_refs)
127 |
128 | return code_found
129 |
130 | def get_matching_result_item(full_text, selected_shortcodes=[], pattern_format="article_code"):
131 | """"
132 | Renvoie les références des articles détectés dans le texte
133 |
134 | Arguments
135 | -----------
136 | full_text: str
137 | a string of the full document normalized
138 | selected_shortcodes: array
139 | a list of selected codes in short format for filtering article detection. Default is an empty list (which stands for no filter)
140 | pattern_format: str
141 | a string representing the pattern format article_code or code_article. Defaut to article_code
142 |
143 | Yields
144 | --------
145 | code_short_name:str
146 |
147 | article_number:str
148 | """
149 | article_pattern = switch_pattern(selected_shortcodes, pattern_format)
150 | # normalisation des espaces dans le texte
151 | full_text = re.sub(r"\r|\n|\t|\f|\xa0", " ", " ".join(full_text))
152 | for i, match in enumerate(re.finditer(article_pattern, full_text)):
153 | needle = match.groupdict()
154 | qualified_needle = {
155 | key: value for key, value in needle.items() if value is not None
156 | }
157 | msg = f"#{i+1}\t{qualified_needle}"
158 | # logging.debug(msg)
159 | # get the code shortname based on regex group name
160 | code = [k for k in qualified_needle.keys() if k not in ["ref", "art"]][0]
161 |
162 | ref = match.group("ref").strip()
163 | # split multiple articles of a same code example: Article 22, 23 et 24 du Code
164 | refs = [
165 | n
166 | for n in re.split(r"(\set\s|,\s|\sdu)", ref)
167 | if n not in [" et ", ", ", " du", " ", ""]
168 | ]
169 | # normalize articles to remove dots, spaces, caret and 'alinea'
170 | refs = [
171 | "-".join(
172 | [
173 | r
174 | for r in re.split(r"\s|\.|-", ref)
175 | if r not in [" ", "", "al", "alinea", "alinéa"]
176 | ]
177 | )
178 | for ref in refs
179 | ]
180 | # clean caracters for everything but numbers and (L|A|R|D) and caret
181 | for ref in refs:
182 | # accepted caracters for article
183 | # exemple: 1224 du => Non 298 al 32 => Non R-288 => oui A-24-14=> oui
184 | ref = "".join(
185 | [n for n in ref if (n.isdigit() or n in ["L", "A", "R", "D", "-"])]
186 | )
187 | if ref.endswith("-"):
188 | ref = ref[:-1]
189 | # remove caret separating article nb between first letter
190 | # exemple: L-248-1 = > L248-1
191 | special_ref = ref.split("-", 1)
192 | if special_ref[0] in ["L", "A", "R", "D"]:
193 | yield(code, "".join(special_ref))
194 |
195 | else:
196 | yield(code, ref)
--------------------------------------------------------------------------------
/parsing.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | # filename: parsing.py
3 |
4 | """
5 | Parsing file module:
6 |
7 | Load document with the accepted extensions and transform into list of text
8 |
9 | """
10 |
11 |
12 | import docx
13 | from PyPDF2 import PdfReader
14 | from odf import text, teletype
15 | from odf.opendocument import load
16 |
17 | ACCEPTED_EXTENSIONS = ("odt", "pdf", "docx", "doc")
18 |
19 |
20 | def parse_doc(file_path):
21 | """
22 | Parcourir le document pour en extraire le texte
23 | Arguments
24 | ----------
25 | file_path: str
26 | absolute filepath of the document
27 | Returns
28 | ----------
29 | full_text: array
30 | a list of sentences.
31 | Raises
32 | ----------
33 | Exception:
34 | Extension incorrecte. Les types de fichiers supportés sont odt, doc, docx, pdf
35 | FileNotFoundError:
36 | File has not been found. File_path must be incorrect
37 | """
38 |
39 | doc_name, doc_ext = file_path.split("/")[-1].split(".")
40 | if doc_ext not in ACCEPTED_EXTENSIONS:
41 | raise ValueError(
42 | "Extension incorrecte: les fichiers acceptés terminent par *.odt, *.docx, *.doc, *.pdf"
43 | )
44 |
45 | full_text = []
46 | if doc_ext == "pdf":
47 | with open(file_path, "rb") as f:
48 | reader = PdfReader(f)
49 |
50 | for i in range(len(reader.pages)):
51 | page = reader.pages[i]
52 | full_text.extend((page.extract_text()).split("\n"))
53 |
54 | elif doc_ext == "odt":
55 | with open(file_path, "rb") as f:
56 | document = load(f)
57 | paragraphs = document.getElementsByType(text.P)
58 | for i in range(len(paragraphs)):
59 | full_text.append((teletype.extractText(paragraphs[i])))
60 | else:
61 | # if doc_ext in ["docx", "doc"]:
62 | with open(file_path, "rb") as f:
63 | document = docx.Document(f)
64 | paragraphs = document.paragraphs
65 | for i in range(len(paragraphs)):
66 | full_text.append((paragraphs[i].text))
67 | full_text = [n for n in full_text if n not in ["\n", "", " "]]
68 | os.remove(file_path)
69 | return full_text
--------------------------------------------------------------------------------
/pytest.ini:
--------------------------------------------------------------------------------
1 | [pytest]
2 | env_files =
3 | .env
4 | .test.env
5 | .deploy.env
--------------------------------------------------------------------------------
/request_api.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python3
2 | # filename: request_api.py
3 | """
4 | Module pour requeter l'API
5 |
6 | - authentification
7 | - get_article_id
8 | - get_article_content
9 | - get_article: module complet avec le status de l'article
10 | """
11 |
12 | import requests
13 | import time
14 | from dotenv import load_dotenv
15 | from code_references import get_code_full_name_from_short_code
16 | from check_validity import convert_epoch_to_datetime, convert_datetime_to_str, get_validity_status
17 |
18 | API_ROOT_URL = "https://sandbox-api.piste.gouv.fr/dila/legifrance-beta/lf-engine-app/"
19 | # API_ROOT_URL = "https://api.piste.gouv.fr/dila/legifrance-beta/lf-engine-app/",
20 |
21 |
22 |
23 | def get_legifrance_auth(client_id, client_secret):
24 | """
25 | Get authorization token from LEGIFRANCE API
26 |
27 | Arguments
28 | ---------
29 | client_id: str
30 | OAUTH CLIENT key provided by API
31 | client_secret: str
32 | OAUTH SECRET key provided by API
33 |
34 | Returns
35 | ---------
36 | authorization_header: dict
37 | a header composed of a json dict with access_token
38 |
39 | Raise
40 | ------
41 | Exception:
42 | No credentials have been set. Client_id or client_secret is None
43 | Exception:
44 | Invalid credentials. Request to authentication server failed with 400 or 401 error
45 | """
46 |
47 | TOKEN_URL = "https://sandbox-oauth.piste.gouv.fr/api/oauth/token"
48 | # TOKEN_URL = "https://sandbox-oauth.aife.economie.gouv.fr/api/oauth/token"
49 |
50 | if client_id is None or client_secret is None:
51 | # return HTTPError(401, "No credential have been set")
52 | raise ValueError(
53 | "No credential: client_id or/and client_secret are not set. \nPlease register your API at https://developer.aife.economie.gouv.fr/"
54 | )
55 | session = requests.Session()
56 | with session as s:
57 | res = s.post(
58 | TOKEN_URL,
59 | data={
60 | "grant_type": "client_credentials",
61 | "client_id": client_id,
62 | "client_secret": client_secret,
63 | "scope": "openid",
64 | },
65 | )
66 |
67 | if res.status_code in [400, 401]:
68 | # return HTTPError(res.status_code, "Unauthorized: invalid credentials")
69 | raise Exception(f"HTTP Error code: {res.status_code}: Invalid credentials")
70 | token = res.json()
71 | access_token = token["access_token"]
72 | return {"Authorization": f"Bearer {access_token}"}
73 |
74 |
75 | def get_article_uid(short_code_name, article_number, headers):
76 | """
77 | GET the article uid given by [Legifrance API](https://developer.aife.economie.gouv.fr/index.php?option=com_apiportal&view=apitester&usage=api&apitab=tests&apiName=L%C3%A9gifrance+Beta&apiId=426cf3c0-1c6d-46ba-a8b0-f79289086ed5&managerId=2&type=rest&apiVersion=1.6.2.5&Itemid=402&swaggerVersion=2.0&lang=fr)
78 |
79 | Arguments
80 | ---------
81 | code_name:str
82 | Nom du code de droit français (version courte)
83 | article_number: str
84 | Référence de l'article mentionné (version normalisée eg. L25-67)
85 |
86 | Returns
87 | --------
88 | article_uid: str
89 | Identifiant unique de l'article dans Legifrance LEGIART000xxxx or None
90 | Raises
91 | ------
92 | ValueError:
93 | Le nom du code est incorrect
94 | Exception:
95 | La requete a échoué response.status_code [400-500]
96 | """
97 | long_code = get_code_full_name_from_short_code(short_code_name)
98 | if long_code is None:
99 | raise ValueError(f"`{short_code_name}` not found in the supported Code List")
100 |
101 | session = requests.Session()
102 |
103 | today_epoch = int(time.time()) * 1000
104 | data = {
105 | "recherche": {
106 | "champs": [
107 | {
108 | "typeChamp": "NUM_ARTICLE",
109 | "criteres": [
110 | {
111 | "typeRecherche": "EXACTE",
112 | "valeur": article_number,
113 | "operateur": "ET",
114 | }
115 | ],
116 | "operateur": "ET",
117 | }
118 | ],
119 | "filtres": [
120 | {"facette": "NOM_CODE", "valeurs": [long_code]},
121 | {"facette": "DATE_VERSION", "singleDate": today_epoch},
122 | ],
123 | "pageNumber": 1,
124 | "pageSize": 10,
125 | "operateur": "ET",
126 | "sort": "PERTINENCE",
127 | "typePagination": "ARTICLE",
128 | },
129 | "fond": "CODE_DATE",
130 | }
131 | with session as s:
132 | response = s.post(
133 | "/".join([API_ROOT_URL, "search"]), headers=headers, json=data
134 | )
135 | if response.status_code > 399:
136 | # print(response)
137 | # return None
138 | raise Exception(f"Error {response.status_code}: {response.reason}")
139 |
140 | article_informations = response.json()
141 | if not article_informations["results"]:
142 | return None
143 |
144 | results = article_informations["results"]
145 | if len(results) == 0:
146 | return None
147 | else:
148 | # get the first result
149 | try:
150 | return results[0]["sections"][0]["extracts"][0]["id"]
151 | except IndexError:
152 | return None
153 |
154 |
155 |
156 | def get_article_content(article_id, headers):
157 | """
158 | GET article_content from LEGIFRANCE API using POST /consult/getArticle https://developer.aife.economie.gouv.fr/index.php?option=com_apiportal&view=apitester&usage=api&apitab=tests&apiName=L%C3%A9gifrance+Beta&apiId=426cf3c0-1c6d-46ba-a8b0-f79289086ed5&managerId=2&type=rest&apiVersion=1.6.2.5&Itemid=402&swaggerVersion=2.0&lang=fr
159 |
160 | Arguments
161 | ----------
162 | article_id: str
163 | article uid eg. LEGIARTI000006307920
164 | Returns
165 | -------
166 | article_content: dict
167 | a dictionnary with the full content of article
168 | Raise
169 | -------
170 | Exception
171 | response.status_code [400-500]
172 | """
173 | data = {"id": article_id}
174 | session = requests.Session()
175 | with session as s:
176 |
177 | response = s.post(
178 | "/".join([API_ROOT_URL, "consult", "getArticle"]),
179 | headers=headers,
180 | json=data,
181 | )
182 |
183 | if response.status_code > 399:
184 | raise Exception(f"Error {response.status_code}: {response.reason}")
185 | article_content = response.json()
186 | try:
187 | raw_article = article_content["article"]
188 | # FEATURE récupérer tous les titres et sections d'un article
189 | article = {
190 | "url": f"https://www.legifrance.gouv.fr/codes/article_lc/{article_id}"
191 | }
192 | for k in [
193 | "id",
194 | "num",
195 | "texte",
196 | "etat",
197 | "dateDebut",
198 | "dateFin",
199 | "articleVersions",
200 | ]:
201 | article[k] = raw_article[k]
202 | # FEATURE - integrer les différentes versions
203 | article["nb_versions"] = len(article["articleVersions"])
204 |
205 | return article
206 | except KeyError:
207 | return None
208 |
209 |
210 | def get_article_content_by_id_and_article_nb(article_id, article_num, headers):
211 | """
212 | Récupère un Article en fonction de son ID et Numéro article depuis API Legifrance GET /consult getArticleWithIdAndNum
213 | Arguments
214 | ---------
215 | article_id: str
216 | article uid eg. LEGIARTI000006307920
217 | article_num: str
218 | numéro de l'article standardisé eg. "3-45", "L214", "R25-64"
219 | Returns
220 | -------
221 | article_content: dict
222 | a dictionnary with the full content of article
223 | Raise
224 | -----
225 | Exception
226 | response.status_code [400-500]
227 | """
228 |
229 | data = {"id": article_id, "num": article_num}
230 |
231 | session = requests.Session()
232 | with session as s:
233 |
234 | response = s.post(
235 | "/".join([API_ROOT_URL, "consult", "getArticleWithIdandNum"]),
236 | headers=headers,
237 | json=data,
238 | )
239 | if response.status_code > 399:
240 | raise Exception(f"Error {response.status_code}: {response.reason}")
241 | article_content = response.json()
242 | return article_content["article"]
243 |
244 | def get_article(short_code_name, article_number, client_id, client_secret, past_year_nb=3, future_year_nb=3):
245 | """
246 | Accéder aux informations simplifiée de l'article
247 |
248 | Arguments
249 | ---------
250 | long_code_name: str
251 | Nom du code de loi française dans sa version longue
252 | article_number: str
253 | Numéro de l'article de loi normalisé ex. R25-67 L214 ou 2667-1-1
254 | Returns
255 | --------
256 | article: str
257 | Un dictionnaire json avec code (version courte), article (numéro), status, status_code, color, url, text, id, start_date, end_date, date_debut, date_fin
258 | """
259 |
260 | article = {
261 | "code": short_code_name,
262 | "code_full_name": get_code_full_name_from_short_code(short_code_name),
263 | "article": article_number,
264 | "status_code": 200,
265 | "status": "OK",
266 | "color": "secondary",
267 | "url": "",
268 | "texte": "",
269 | "date_debut": "",
270 | "date_fin": "",
271 | "id": get_article_uid(
272 | short_code_name, article_number, headers=get_legifrance_auth(client_id, client_secret)
273 | )
274 | }
275 | if article["id"] is None:
276 | article["color"] = "danger"
277 | article["status_code"] = 404
278 | article["status"] = "Indisponible"
279 | article["texte"] = "x"
280 | return article
281 | article_content = get_article_content(
282 | article["id"], headers=get_legifrance_auth(client_id, client_secret)
283 | )
284 | article["texte"] = article_content["texte"]
285 | article["url"] = article_content["url"]
286 | article["start_date"] = convert_epoch_to_datetime(article_content["dateDebut"])
287 | article["end_date"] = convert_epoch_to_datetime(article_content["dateFin"])
288 | article["status_code"], article["status"], article["color"] = get_validity_status(article["start_date"], article["end_date"], past_year_nb, future_year_nb)
289 | article["date_debut"] = convert_datetime_to_str(article["start_date"]).split(" ")[0]
290 | article["date_fin"] = convert_datetime_to_str(article["end_date"]).split(" ")[0]
291 | del article["start_date"]
292 | del article["end_date"]
293 | return article
294 |
295 |
296 |
--------------------------------------------------------------------------------
/requesting.py:
--------------------------------------------------------------------------------
1 | import requests
2 | import os
3 | import time
4 | from dotenv import load_dotenv
5 | import pytest
6 |
7 | API_ROOT_URL = "https://sandbox-api.piste.gouv.fr/dila/legifrance-beta/lf-engine-app/"
8 | # API_ROOT_URL = "https://api.piste.gouv.fr/dila/legifrance-beta/lf-engine-app/",
9 |
10 | MAIN_CODELIST = {
11 | "CCIV": "Code civil",
12 | "CPRCIV": "Code de procédure civile",
13 | "CCOM": "Code de commerce",
14 | "CTRAV": "Code du travail",
15 | "CPI": "Code de la propriété intellectuelle",
16 | "CPEN": "Code pénal",
17 | "CPP": "Code de procédure pénale",
18 | "CASSUR": "Code des assurances",
19 | "CCONSO": "Code de la consommation",
20 | "CSI": "Code de la sécurité intérieure",
21 | "CSP": "Code de la santé publique",
22 | "CSS": "Code de la sécurité sociale",
23 | "CESEDA": "Code de l'entrée et du séjour des étrangers et du droit d'asile",
24 | "CGCT": "Code général des collectivités territoriales",
25 | "CPCE": "Code des postes et des communications électroniques",
26 | "CENV": "Code de l'environnement",
27 | "CJA": "Code de justice administrative",
28 | }
29 |
30 |
31 | def get_code_full_name_from_short_code(short_code):
32 | """
33 | Shortcut to get corresponding full_name from short_code
34 |
35 | Arguments:
36 | short_code: short form of Code eg. CCIV
37 | Returns:
38 | full_name: long form of code eg. Code Civil
39 | """
40 | try:
41 | return MAIN_CODELIST[short_code]
42 | except ValueError:
43 | return None
44 |
45 |
46 | def get_short_code_from_full_name(full_name):
47 | """
48 | Shortcut to get corresponding short_code from full_name
49 |
50 | Arguments:
51 | full_name: long form of code eg. Code Civil
52 | Returns:
53 | short_code: short form of Code eg. CCIV
54 | """
55 | keys = [k for k, v in MAIN_CODELIST.items() if v == full_name]
56 | if len(keys) > 0:
57 | return keys[0]
58 | else:
59 | return None
60 |
61 |
62 | def get_legifrance_auth(client_id, client_secret):
63 | """
64 | Get authorization token from LEGIFRANCE API
65 |
66 | Arguments:
67 | client_id: OAUTH CLIENT key provided by API
68 | client_secret: OAUTH SECRET key provided by API
69 |
70 | Returns:
71 | authorization_header: a header composed of a json dict with access_token
72 |
73 | Raise:
74 | Exception: No credentials have been set. Client_id or client_secret is None
75 | Exception: Invalid credentials. Request to authentication server failed with 400 or 401 error
76 | """
77 |
78 | TOKEN_URL = "https://sandbox-oauth.piste.gouv.fr/api/oauth/token"
79 | # TOKEN_URL = "https://sandbox-oauth.aife.economie.gouv.fr/api/oauth/token"
80 |
81 | if client_id is None or client_secret is None:
82 | # return HTTPError(401, "No credential have been set")
83 | raise ValueError(
84 | "No credential: client_id or/and client_secret are not set. \nPlease register your API at https://developer.aife.economie.gouv.fr/"
85 | )
86 | session = requests.Session()
87 | with session as s:
88 | res = s.post(
89 | TOKEN_URL,
90 | data={
91 | "grant_type": "client_credentials",
92 | "client_id": client_id,
93 | "client_secret": client_secret,
94 | "scope": "openid",
95 | },
96 | )
97 |
98 | if res.status_code in [400, 401]:
99 | # return HTTPError(res.status_code, "Unauthorized: invalid credentials")
100 | raise Exception(f"HTTP Error code: {res.status_code}: Invalid credentials")
101 | token = res.json()
102 | access_token = token["access_token"]
103 | return {"Authorization": f"Bearer {access_token}"}
104 |
105 |
106 | def get_article_uid(code_name, article_number, headers):
107 | """
108 | GET the article uid given by [Legifrance API](https://developer.aife.economie.gouv.fr/index.php?option=com_apiportal&view=apitester&usage=api&apitab=tests&apiName=L%C3%A9gifrance+Beta&apiId=426cf3c0-1c6d-46ba-a8b0-f79289086ed5&managerId=2&type=rest&apiVersion=1.6.2.5&Itemid=402&swaggerVersion=2.0&lang=fr)
109 |
110 | Arguments:
111 | code_name: Nom du code de droit français (version longue)
112 | article_number: Référence de l'article mentionné (version normalisée eg. L25-67)
113 |
114 | Returns:
115 | article: un dictionnaire qui contient l'identifiant unique de l'article dans legifrance, le nom du code en version courte et en version longue
116 | article_uid: Identifiant unique de l'article dans Legifrance or None
117 |
118 | """
119 | if code_name in list(MAIN_CODELIST.keys()):
120 | code_short = code_name
121 | code_long = MAIN_CODELIST[code_name]
122 | elif code_name in list(MAIN_CODELIST.values()):
123 | code_long = code_name
124 | code_short = get_short_code_from_full_name(code_long)
125 | else:
126 | raise ValueError(f"`{code_name}` not found in the supported Code List")
127 |
128 | session = requests.Session()
129 |
130 | today_epoch = int(time.time()) * 1000
131 | data = {
132 | "recherche": {
133 | "champs": [
134 | {
135 | "typeChamp": "NUM_ARTICLE",
136 | "criteres": [
137 | {
138 | "typeRecherche": "EXACTE",
139 | "valeur": article_number,
140 | "operateur": "ET",
141 | }
142 | ],
143 | "operateur": "ET",
144 | }
145 | ],
146 | "filtres": [
147 | {"facette": "NOM_CODE", "valeurs": [code_long]},
148 | {"facette": "DATE_VERSION", "singleDate": today_epoch},
149 | ],
150 | "pageNumber": 1,
151 | "pageSize": 10,
152 | "operateur": "ET",
153 | "sort": "PERTINENCE",
154 | "typePagination": "ARTICLE",
155 | },
156 | "fond": "CODE_DATE",
157 | }
158 | with session as s:
159 | response = s.post(
160 | "/".join([API_ROOT_URL, "search"]), headers=headers, json=data
161 | )
162 | if response.status_code > 399:
163 | # print(response)
164 | # return None
165 | raise Exception(f"Error {response.status_code}: {response.reason}")
166 |
167 | article_informations = response.json()
168 | if not article_informations["results"]:
169 | return None
170 |
171 | results = article_informations["results"]
172 | if len(results) == 0:
173 | return None
174 | else:
175 | # get the first results
176 | try:
177 | article_uid = results[0]["sections"][0]["extracts"][0]["id"]
178 | except IndexError:
179 | return None
180 | # article = {
181 | # "id": article_uid,
182 | # "code_name_short": code_short,
183 | # "code_name_long": code_long,
184 | # }
185 | return article_uid
186 |
187 |
188 | def get_article_content(article_id, headers):
189 | """
190 | GET article_content from LEGIFRANCE API using POST /consult/getArticle https://developer.aife.economie.gouv.fr/index.php?option=com_apiportal&view=apitester&usage=api&apitab=tests&apiName=L%C3%A9gifrance+Beta&apiId=426cf3c0-1c6d-46ba-a8b0-f79289086ed5&managerId=2&type=rest&apiVersion=1.6.2.5&Itemid=402&swaggerVersion=2.0&lang=fr
191 |
192 | Arguments:
193 | article_id: article uid eg. LEGIARTI000006307920
194 | Returns:
195 | article_content: a dictionnary with the full content of article
196 | Raise:
197 | Exception : response.status_code [400-500]
198 | """
199 | data = {"id": article_id}
200 | session = requests.Session()
201 | with session as s:
202 |
203 | response = s.post(
204 | "/".join([API_ROOT_URL, "consult", "getArticle"]),
205 | headers=headers,
206 | json=data,
207 | )
208 |
209 | if response.status_code > 399:
210 | raise Exception(f"Error {response.status_code}: {response.reason}")
211 | article_content = response.json()
212 | try:
213 | raw_article = article_content["article"]
214 | # FEATURE récupérer tous les titres et sections d'un article
215 | article = {
216 | "url": f"https://www.legifrance.gouv.fr/codes/article_lc/{article_id}"
217 | }
218 | for k in [
219 | "id",
220 | "num",
221 | "texte",
222 | "etat",
223 | "dateDebut",
224 | "dateFin",
225 | "articleVersions",
226 | ]:
227 | article[k] = raw_article[k]
228 | # FEATURE - integrer les différentes versions
229 | article["nb_versions"] = len(article["articleVersions"])
230 |
231 | return article
232 | except KeyError:
233 | return None
234 |
235 |
236 | def get_article_content_by_id_and_article_nb(article_id, article_num, headers):
237 | """
238 | Récupère un Article en fonction de son ID et Numéro article depuis API Legifrance GET /consult getArticleWithIdAndNum
239 | Arguments:
240 | article_id: article uid eg. LEGIARTI000006307920
241 | article_num: numéro de l'article standardisé eg. "3-45", "L214", "R25-64"
242 | Returns:
243 | article_content: a dictionnary with the full content of article
244 | Raise:
245 | Exception : response.status_code [400-500]
246 | """
247 |
248 | data = {"id": article_id, "num": article_num}
249 |
250 | session = requests.Session()
251 | with session as s:
252 |
253 | response = s.post(
254 | "/".join([API_ROOT_URL, "consult", "getArticleWithIdandNum"]),
255 | headers=headers,
256 | json=data,
257 | )
258 | if response.status_code > 399:
259 | raise Exception(f"Error {response.status_code}: {response.reason}")
260 | article_content = response.json()
261 | return article_content["article"]
262 |
263 |
264 |
--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | bottle==0.12.23
2 | python-docx==0.8.11
3 | python-dotenv==0.20.0
4 | odfpy==1.4.1
5 | requests==2.27.1
6 | pdfminer.six==20220524
7 | urllib3~=1.26.11
8 | PyPDF2~=2.10.2
9 | pytest~=7.2.0
10 | pytest-dotenv==0.5.2
--------------------------------------------------------------------------------
/result_templates.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python3
2 | # coding: utf-8
3 |
4 | start_results="""
5 |
6 |
7 |
8 |
9 |
10 |
11 | Code is low - Accueil
12 |
13 |
14 |
15 |
16 |
17 |
40 |
Le développeur propose, à titre gracieux et non-professionnel, un outil
9 | expérimental d'aide au traitement de textes juridiques. Il décline toute
10 | responsabilité pour le cas où les références à des articles de codes de droit français ne seraient
11 | pas correctement détectées. La responsabilité de l'exactitude des informations figurant sur la base
12 | de données Légifrance relève, quant à elle,
13 | exclusivement de la DILA. Pour le surplus,
14 | l'utilisation de ce logiciel est soumise à la licence CeCILL.
16 |
17 |
18 |
L'application web est proposée par E. Netter, à titre individuel, sans impliquer l'université à
19 | laquelle il appartient. E. Netter est responsable du traitement des données à caractère personnel
20 | que vos documents pourraient contenir, au sens du règlement général sur la protection des
22 | données et de la loi
23 | informatique et libertés. Le serveur est opéré par Heroku, qui occupe une position de sous-traitant des données,
25 | rémunéré par E. Netter. Vos données sont traitées sur le fondement de la nécessité pour l'exécution
26 | d'une prestation de service dont vous demandez à bénéficier (art. 6,
28 | 1, b RGPD).
29 |
30 |
31 |
Politique de confidentialité
32 |
Conformément au code
33 | source public, votre document est copié dans un fichier provisoire uniquement le temps
34 | d'être traité, puis supprimé (ligne "os.remove") avant même l'affichage des résultats. Au cas où la
35 | suppression échouerait en raison d'un bug, les fichiers sont automatiquement détruits par Heroku
36 | toutes les 24h, et le développeur s'engage à ne pas en prendre connaissance. Si vous souhaitez
37 | cependant qu'il examine votre document afin de comprendre pourquoi un examen a échoué, vous pouvez
38 | choisir de lui adresser, à l'adresse email située en bas de page. Il s'engage alors à ne
39 | l'exploiter à aucune autre fin puis à la détruire. L'échange entre votre navigateur et le serveur
40 | doit être chiffré. Si votre navigateur présente un cadenas ouvert ou indique que la connexion n'est
41 | pas sécurisée, il s'agit d'un dysfonctionnement et l'outil ne devrait pas être utilisé.
42 |
43 |
Il est également possible de préférer à cette application web une exécution locale du code source sur votre propre système
45 | informatique. C'est le mode vivement recommandé pour le cas où votre document contiendrait des
46 | données confidentielles, particulièrement sensibles, ou soumises au secret professionnel.
47 | Rapprochez-vous de la personne responsable de vos systèmes d'information. L'ouverture d'un compte développeur PISTE (rapide et
49 | gratuite) sera alors nécessaire.
50 |
51 |
Les droits qui vous sont reconnus par le RGPD et la LIL vous
53 | sont présentés par l'auteur sur son site de chercheur en droit.
54 |
55 |
Si vous estimez que vos droits ont été méconnus, je vous invite à me contacter avant toute autre
56 | démarche, à l'adresse email figurant en haut de la page. Vous disposez du droit de déposer une
57 | réclamation auprès de la
58 | CNIL.
Soumettez le texte que vous souhaitez analyser
12 | au format DOC, DOCX ou ODT (de préférence) ou PDF.
13 | Le format PDF n'est pas toujours lisible. Les résultats peuvent être faussés.
14 |
15 | Actuellement, la taille du fichier est limitée à 2 Mospan>
16 |
17 |
Définissez la plage temporelle de surveillance pour les articles
18 |
Selectionnez les codes qui vous concernent
19 |
20 |
21 | Le programme recherchera des références à des articles de code
22 | (ex : "art. 1240 C. civ.", "article L. 110-1 du Code de commerce").
Il interrogera Légifrance à propos des articles détectés.
23 |
24 |
Vous saurez ainsi :
25 |
Si le texte est introuvable sur Légifrance (abrogé, faute de frappe, erreur de détection, de mention...)
26 |
Si le texte a été récemment modifié (période définie par vous) (N.B. : seule la modification la plus récente est mentionnée)
27 |
Si le texte va être modifié prochainement (période définie par vous) N.B. : seule la version à venir la plus proche est mentionnée)
28 |
Si le texte n'a pas été modifié(pendant la période définie)