L'esprit de mon code est d'utiliser autant que possible la programmation fonctionnelle pcq c'est plus pratique et surtout plus facile à lire et corriger.

Voici l'arborescence du projet:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
scrapy_project
 |_ scrapy.cfg
 |_ scrapy_project
      |_ __init__.py
      |_ module_parsing.py
      |_ module_correction.py
      |_ items.py
      |_ ...
      |_ spiders
            |_ crawling_spider.py
`module_parsing.py` et `module_correction.py` sont des modules que j'ai créé.

En résumé ce que ces modules contiennent:
Dans le `module_parsing.py` on a ce genre de fonctions très simples.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
import re
import datetime as dt
import dateparser
 
def noms_entraineurs(response, arg_disc):
    """Return a list of names"""
    ent = parse instructions
    return ent
etc.

Et parce que je ne peux pas toujours anticiper les erreurs de parsing mais que je veux les corriger et pas manuellement pour faire des MAJ via un pipeline tout simplement, c'est pourquoi dans une méthode spécifique de mon spider j'ai envisagé une fonction, présente dans le module `module_correction.py`, dans laquelle se trouve un dictionnaire pour lequel la clé est le champ en str et le valeur est une fonction de parsing qui correspond à ce champ et se trouve dans le module `module_parsing.py`.

Ça donne qqch comme ceci:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
from .module_parsing import *
def fonction_parse_correction(
    field, response, arg_desc, arg_disc, arg_true_false):
 
    dico_fonction_parse = {
        'discipline': discipline(arg_desc),
        ...
        'entraineurs' : noms_entraineurs(response,
                                    arg_disc),
        ...
        }
    return dico_fonction_parse[field]
Ainsi j’espérai avoir à écrire seulement ceci:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
fonction_parse_correction(field, response, arg_desc, arg_disc, arg_true_false)
C'est ce que j'ai tenté de faire dans scrapy shell mais cela a échoué avec l'erreur : `NameError: name 'function_name' is not defined`

L'essai dans scrapy shell

J'ai lancé dans la console `scrapy shell https://website.com`

Ensuite j'ai importé mes modules personnalisé et cela donne la chose suivante:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
In [1]: import sys                                                              
 
In [2]: sys.path.insert(0,'/home/user/directory_a/.../scrapy_project/scrapy_project')
 
In [3]: from module_parsing import * 
    #ça marche bien donc la méthode d'importation est ok ici
    ...
In [7]: from module_correction import * 
    ...
In [10]: fonction_parse_correction('entraineurs',response,arg_desc,'attele',False)
 
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-10-137e645b094c> in <module>
----> 1 fonction_parse_correction('entraineurs',response,arg_desc,'attele',False)
 
~/.../scrapy_project/scrapy_project/module_correction.py in fonction_parse_correction(field, response, arg_desc, arg_disc, arg_true_false)
     50 
     51     dico_fonction_parse = {
---> 52     'allocation': allocation_devise(response)[0],
     53     'devise': allocation_devise(response)[1],
     54     'hippodrome':hippodrome_numreu_prix(response)[0],
 
NameError: name 'allocation_devise' is not defined
Et c'est là que je suis coincé, pcq je ne comprend pas l'erreur `NameError` alors que j'ai explicitement importé `module_parsing.py` dans le module `module_correction.py` afin d'obtenir les fonctions et leur noms de références.

Notes:
Ubuntu 18.04, Scrapy 1.5.2, Python 3.7.1