Discussion :

[seb6051]

Bonjour,

Alors voila j'ai accès à un livre en ligne mais souvent j'aimerai en avoir besoin hors connexion car plus rapide d'accès ca m'evite de remettre mes identifiants.
J'ai donc besoin d'un petit script qui permettrait de copier les page de ce livre automatiquement pour les avoir en JPG ou PDF hors ligne.

Si quelqu'un peut m'expliquer comment faire je suis preneur .

Merci

[wiztricks]

Salut,

Faire cela dépend du site Web (via lequel on accède au livre)... et des droits de copies associés.
Acheter une copie numérique sera plus simple!

- W

[Sve@r]

Bonjour
Du côté de Python il y a le module selenium qui peut lancer un navigateur et lui faire effectuer des actions comme remplir un formulaire ou autre. Mais en dehors du cadre légal (peut-être que les règles de lecture du site imposent une lecture "en ligne" ce qui interdit toute "aspiration" telle que tu l'imagines), dans le meilleur des cas tu obtiendras une copie "image" du livre, comme si tu faisais des copies d'écran page par page.
Et cela t'interdira tout style de recherche comme recherche par mot (ce qui est bien pratique sur les livres numériques).

[wiztricks]

Et cela t'interdira tout style de recherche comme recherche par mot (ce qui est bien pratique sur les livres numériques)..

On pourrait ajouter une couche OCR pour traiter ce détail...

- W

[marco056]

Comme dit précédemment, cela dépendra du site. De mon côté, j'ai un script qui me fait cela.
A adapter peut-être ?

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
import subprocess
import requests
from requests.exceptions import ConnectionError
 
def isurl(url_test) :
    try:
        response = requests.get(url)
        response.raise_for_status()
        return True
    except requests.exceptions.HTTPError as err:
        if err.response.status_code == 404:
            print("404 Error")
            return False
 
###############################################################################
############################### à modifier ####################################
###############################################################################
repertoire = ...
url_manuel = ...
nom_fichier_pdf = "...pdf"
 
###############################################################################
# si le nombre de pages dépasse 2000, changer le nombre
num_page = 1
while num_page < 2000:
    url = url_manuel.format(num_page)
    if isurl(url):
        sortie = "page{}.pdf".format(num_page)
        print(sortie)
        subprocess.run(['wkhtmltopdf', url, sortie], cwd=repertoire)
        num_page+=1
    else:
        break
 
nb_pages = num_page-1
 
######################### assemblage des pages ###################################
import PyPDF2
 
## création de la liste des pages à assembler
liste_pages = ["page{}.pdf".format(num_page) for num_page in range(1,nb_pages+1)]
 
# fonction d'assemblage
def pdf_combine(pdf_liste):
    """ fonction d'assemblage des pages en pdf présentes
    dans pdf_liste"""
    merger = PyPDF2.PdfMerger()
    for pdf in pdf_liste:
        merger.append(pdf)
    merger.write(nom_fichier_pdf)
 
# on assemble
pdf_combine(liste_pages)
 
import os
cpt=0 # compteur fichiers supprimés
 
######################### effacage des pages ###################################
# on efface les fichiers de toutes les pages pdf une fois combinées
# Parcours récursif des répertoires
for fichier in liste_pages:
    # affiche les fichiers supprimés
    print(fichier, ' supprimé')
    # efface les fichiers
    os.remove(fichier)
    # incrémente le compteur de fichiers supprimés
    cpt+=1            
 
print(cpt, ' fichiers supprimé(s) !')

[Sve@r]

A adapter peut-être ?

Peut-être. La boucle jusqu'à 2000... (j'aurais mis un while True puisque de toute façon tu as une porte de sortie). Et ce "break" sera plus à sa place avec un test écrit dans le bon sens (ce qui aura au-moins l'avantage de gagner une tabulation)

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
# si le nombre de pages dépasse 2000, on s'en balec
num_page = 1
while True:
    url = url_manuel.format(num_page)
    if not isurl(url): break
    sortie = "page{}.pdf".format(num_page)
    print(sortie)
    subprocess.run(['wkhtmltopdf', url, sortie], cwd=repertoire)
    num_page+=1

Ceci dit, je te remercie de ton intervention qui m'a appris l'existence de wkhtmltopdf

[wiztricks]

A adapter peut-être ?

sve@r est gentil!

Pour adapter, ça serait mieux que ce soit un peu moins brouillon.
Moi aussi j'ai tiqué sur la remarque # si le nombre de pages dépasse 2000, changer le nombre.
Déjà si on a 500 pages, c'est "gros"...
Du coup, on sort rarement de la boucle à cause de cette condition mais plutôt via ce que retourne la fonction isurl.

Si on s'y penche un peu:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
def isurl(url_test) :
    try:
        response = requests.get(url)
        response.raise_for_status()
        return True
    except requests.exceptions.HTTPError as err:
        if err.response.status_code == 404:
            print("404 Error")
            return False

On passe une variable en paramètre pour utiliser une variable globale dans le corps de la fonction.

Après on a un soucis de logique: si on suppose que 404 signale que toutes les pages du bouquin ont été lues et que la fonction retournera False dans ce cas, on ignore les autres erreurs qui vont aussi retourner False (puisque c'est ce que retourne par défaut une fonction), erreurs qui pourraient être sujet à reprise.

Autre détail, puisqu'on ne teste que l'existence de l'URL, inutile de demander au serveur de nous retourner le contenu: ça évite de charge disque, serveur, réseau,... et ça demande juste de remplacer requests.get par requests.head.

Mais on ne va pas réécrire cette fonction puisqu'elle n'est là que pour suppléer à une utilisation "molle" de subprocess:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

             subprocess.run(['wkhtmltopdf', url, sortie], cwd=repertoire)

Car subprocess.run retourne une instance de CompletedProcess dans lequel l'attribut returncode va dire si l'opération s'est bien déroulée ou pas. on peut même demander a ce qu'une exception soit levée dans ce cas (check=True).
Et si l'URL n'existe pas, ça sortira en erreur...

Du coup, ça donne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
from itertools import count
 
for num_pages in count(start=1):
    url = url_manuel.format(num_page)
    sortie = "page{}.pdf".format(num_page)
    print(sortie)
    s = subprocess.run(['wkhtmltopdf', url, sortie], cwd=repertoire, text=True, capture_output=True)
    if s.returncode != 0:
         if s.stderr.splitlines()[-1].split()[-1] == 'ContentNotFoundError':
               print("404 Error")
         break

ce qui à priori est fonctionnellement équivalent (pas mieux pas moins bien) en 7-8 lignes au lieu de 20+.

- W

[fred1599]

Hello,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
while num_page < 2000:
    url = url_manuel.format(num_page)
    if isurl(url):
        # suite du code

Si ça passe, c'est que le serveur est bien gentil !

Je limiterai le nombre de requêtes par minute, à moins de se faire jeter et blacklister.

[wiztricks]

Je limiterai le nombre de requêtes par minute, à moins de se faire jeter et blacklister.

wkhtmltopdf prend son temps: charger le browser, lui demander de charger la page (qui peut être "riche" en contenu), la sauvegarder en PDF.... Si on arrive à faire une page par seconde, c'est bien.
Mieux serait de demander à wkhtmltopdf de récupérer plusieurs pages consécutives et éventuellement paralléliser un peu.
Ce qui ouvre aussi la porte à des reprises en cas d'erreurs et à leur gestion... plus intéressant mais beaucoup plus compliqué (que le code initial).

- W

[fred1599]

Salut !

@wiztricks,

Tu as raison, et pour le coup ça peut devenir trop lent et long, dans ce cas il serait peut-être bon de faire de l'asynchrone pour rendre la tâche non bloquante et mettre un temps de pause (1 seconde) pour éviter les surcharges réseaux.

[wiztricks]

En fait, je n'aime pas du tout wkhtmltopdf: il fait trop de choses dans son subprocess pour lequel on ne contrôle rien du tout. Pour optimiser, pas facile! Il semble que de nouvelles bibliothèques plus généralistes soient sorties cefpython3, pyppeteer, playwright,...
Si je devais "optimiser", je regarderais du côté de ces bibliothèques pour voir ce qu'on pourrait faire avec un découpage plus fin...

- W