Retour à la ligne impossible

**Rudeus** · 04/08/2023, 20h53

Bonjour,

Impossible de parvenir à effectuer un retour à la ligne sur ma chaine de caractère.

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
        dn = dns.resolver.query(n, 'ns')
        list_ns = []
        for rdata in dn:
            ns = rdata.to_text()
            list_ns.append(ns)
 
        no_listens = str(list_ns)
 
        # On récupère le champ A du domaine
 
        n = dns.name.from_text(domain_name)
 
        a = dns.resolver.query(n, 'A')
 
        list_a = []
        for rdata in a:
            domain_a = str(rdata.to_text())
            list_a.append(domain_a)
 
 
        no_liste_a = str(list_a)
 
serveurs_dns = f"Serveurs DNS : {no_listens}\n"
entree_a = f"Adresse IPv4 de {no_liste_a}"

Je souhaite avoir un retour à la ligne entre mes deux valeurs mais tout reste sur la même ligne. Je ne comprends pas pourquoi

Une idée ?

**wiztricks** · 05/08/2023, 00h01

Salut,

Envoyé par Rudeus

Une idée ?

Le seul retour à la ligne dans le code que vous montrez est à la ligne 23 et on ne voit pas trop comment ces variables sont utilisées dans le reste du code.

Avec ça difficile de comprendre ce que vous racontez et comment vous aider.

Prenez le temps de mieux décrire le problème rencontré! Pour trouver une solution, décrire correctement le problème est la première étape. Elle peut se réduire à fabriquer un code simple qui permette de reproduire constaté.

- W

**Rudeus** · 05/08/2023, 00h10

En effet j'aurais du préciser comment elles sont utilisées !

Je remets donc le code complet avec les explications.

J'ai créé une fonction qui permet de récupérer les données DNS d'un domaine entré :

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
def dns_lookup(domain_name: str):
 
    # On récupère les DNS
    # print(domain)
 
    n = dns.name.from_text(domain_name)
 
    try:
        dn = dns.resolver.query(n, 'ns')
        list_ns = []
        for rdata in dn:
            ns = rdata.to_text()
            list_ns.append(ns)
 
        no_listens = str(list_ns)
 
        # On récupère le champ A du domaine
 
        n = dns.name.from_text(domain_name)
 
        a = dns.resolver.query(n, 'A')
 
        list_a = []
        for rdata in a:
            domain_a = str(rdata.to_text())
            list_a.append(domain_a)
 
 
        no_liste_a = str(list_a)
 
        serveurs_dns = f"Serveurs DNS : {no_listens}\n"
        entree_a = f"Adresse IPv4 de {no_liste_a}"
 
        return serveurs_dns + entree_a
 
    except dns.resolver.NXDOMAIN:
      return "Le nom de domaine n'existe pas !"

Étant sur un projet Django, j'importe ma fonction dans mon fichier views.py :

Code :

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

1
2
3
4
5
6
7
def onglet_dnslookup(request):
    domain_name = request.POST.get("domain_name")
    try:
        resultat = dns_lookup(domain_name)
        return render(request, 'toolbox/dnslookup.html', {'domain': resultat})
    except ValueError:
        return render(request, 'toolbox/dnslookup.html')

Le résultat est envoyé dans mon fichier dnslookup.html :

Code html :

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
<body>
    <div class="container">
        <div class="row">
            <form method="post" action="">
                {% csrf_token %}
                <label for="domain_name">Nom de domaine :</label>
                <input type="text" id="domain_name" name="domain_name">
                <button type="submit" class="btn btn-primary ">Chercher</button>
            </form>
        </div>
    </div>
 
    <div class="container">
        <div class="row">
            {{ domain }}
        </div>
    </div>
</body>

Voici l'affichage sur le site qui est retourné :

Nom : dnslookup.jpg
Affichages : 110
Taille : 30,1 Ko

Je voudrais que pour chaque entrée, un retour à la ligne soit effectué. Le problème c'est que je n'y parviens pas du tout.

J'espère que c'est plus clair !

**wiztricks** · 05/08/2023, 14h54

Envoyé par Rudeus

Je voudrais que pour chaque entrée, un retour à la ligne soit effectué. Le problème c'est que je n'y parviens pas du tout.

L'engin qui affiche est un navigateur qui récupère des informations dans du HTML ou il devrait montrer un texte en plusieurs lignes.
Comment on fait ça dans du HTML? Sur que c'est plus compliqué que '\n' mais ce n'est pas un sujet Python et Django n'est pas un outil pour débutant.
Vous êtes donc supposé chercher un peu sur Internet avant de demander de l'aide (dans le bon forum).

- W

**binarygirl** · 05/08/2023, 16h06

J'aborderais le problème différemment.
Quand on veut afficher un retour à la ligne dans une page HTML, on convertit \n en <br/>, ou bien on utilise un élement HTML tel que PRE ou CODE pour afficher du texte brut.

Votre fonction dns_lookup ne devrait pas renvoyer un string concaténé, qui manque de souplesse. Renvoyez plutôt un dict par exemple, puisque vous mélangez différents type d'enregistrements (A, NS).
Ensuite, vous passez ce dict à Django pour qu'il l'affiche par exemple avec <ul><li>. Et en passant, vous pourriez même trier par ordre alphabétique ou autre.

D'autre part, il y a du code répétitif dans la fonction dns_lookup. Il faudrait lui rajouter un argument qui indique le type de ressource (A, NS, autre) recherché, et alors vous l'appelez deux fois. Voire trois, si vous voulez inclure les adresses IPv6...
Je vous conseille donc de récupérer les A et les NS de manière distincte.

En plus, ces list append n'ont pas de sens... il serait plus judicieux d'utiliser ce que la lib dns vous renvoie déjà, en filtrant ce qui vous intéresse. Cela peut se faire par un classique list comprehension.

Voici une proposition de fonction plus généraliste, à laquelle vous devrez encore rajouter un peu de gestion d'exception:

Code :

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

1
2
3
4
5
6
7
8
def dns_lookup(domain_name: str, resource_type: str):
    answers = dns.resolver.resolve(domain_name, resource_type)
    return [rdata.to_text() for rdata in answers]
 
domain_name = "test.com"
print(dns_lookup(domain_name=domain_name, resource_type="NS"))
print(dns_lookup(domain_name=domain_name, resource_type="A"))
print(dns_lookup(domain_name=domain_name, resource_type="AAAA"))

Enfin, notez que dns.resolver.query est deprecated, utilisez plutôt dns.resolver.resolve

**Rudeus** · 05/08/2023, 17h15

Bonjour !

Ah oui en effet votre code est beaucoup plus court et plus efficace que le miens ...

Quand vous parlez de renvoyer un dict plutôt qu'une chaine de caractères concaténée, je dois créer ce dict au niveau de la fonction directement ?

Ou je peux le créer dans mon fichier views là où j'appelle ma fonction ?

Car si je crée le dictionnaire dans la fonction, le return que vous avez indiqué va devoir changer je suppose afin de renvoyer chaque resource_type dans le même return.

Merci en tout cas je comprends un peu mieux le fonctionnement de tout ça

EDIT :

J'ai testé avec ce code dans mon views :

Code :

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

1
2
3
4
5
6
7
8
9
def onglet_dnslookup(request):
    domain_name = request.POST.get("domain_name")
    try:
        ns = dns_lookup(domain_name, "NS")
        a = dns_lookup(domain_name, "A")
        dic = dict([("ns",ns), ("a",a)])
        return render(request, 'toolbox/dnslookup.html', {'dic': dic})
    except ValueError:
        return render(request, 'toolbox/dnslookup.html')

C'est comme cela que vous m'indiquiez de faire ?

**binarygirl** · 05/08/2023, 17h51

Envoyé par Rudeus

Quand vous parlez de renvoyer un dict plutôt qu'une chaine de caractères concaténée, je dois créer ce dict au niveau de la fonction directement ?

C'est une question de choix. Personnellement, je garderais cette fonction telle quelle car elle est généraliste et réutilisable.
Mais on peut dans la foulée envelopper tout ça dans une fonction un peu plus spécialisée.
Mais comme les clés d'un dict doivent être uniques, je prônerais plutôt un list of tuples (ou une autre structure).

Si on fait ça en réutilisant la fonction dns_lookup:

Code :

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

1
2
3
4
5
6
7
8
9
def get_records(domain_name: str, resource_types: list):
    dns_records = []
    for resource_type in resource_types:
        for answer in dns_lookup(domain_name=domain_name, resource_type=resource_type):
            dns_records.append((answer, resource_type))
    return dns_records
 
domain_name = "google.fr"
print(get_records(domain_name=domain_name, resource_types=["A", "NS"]))

On peut récupérer plusieurs types d'enregistrements à la fois et on obtient:

Code :

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

[('142.250.179.163', 'A'), ('ns1.google.com.', 'NS'), ('ns4.google.com.', 'NS'), ('ns3.google.com.', 'NS'), ('ns2.google.com.', 'NS')]

Mais alors le filtrage devient moins facile.

PS: on pourrait utiliser un namedtuple plutôt qu'un simple tuple.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import dns.resolver
from collections import namedtuple
 
def dns_lookup(domain_name: str, resource_type: str):
    answers = dns.resolver.resolve(domain_name, resource_type)
    return [rdata.to_text() for rdata in answers]
 
def get_records(domain_name: str, resource_types: list):
    dns_records = []
    DnsRecord = namedtuple("DnsRecord", ["RecordType", "Value"])
    for resource_type in resource_types:
        for answer in dns_lookup(domain_name=domain_name, resource_type=resource_type):
            dns_records.append(DnsRecord(RecordType=resource_type, Value=answer))
    return dns_records

La réponse devient alors:

Code :

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

[DnsRecord(RecordType='A', Value='142.250.179.163'), DnsRecord(RecordType='NS', Value='ns3.google.com.'), DnsRecord(RecordType='NS', Value='ns2.google.com.'), DnsRecord(RecordType='NS', Value='ns1.google.com.'), DnsRecord(RecordType='NS', Value='ns4.google.com.')]

On peut filtrer les namedtuples avec un banal list comprehension:

Code :

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

1
2
3
4
domain_name = "google.fr"
all_records = get_records(domain_name=domain_name, resource_types=["A", "NS"])
a_records = [item for item in all_records if item.RecordType == "A"]
ns_records = [item for item in all_records if item.RecordType == "NS"]

NB: gestion d'exception nécessaire, car il n'y aura pas toujours de réponse.

Mais finalement on en revient un peu à la complexité d'origine. Il me semble plus simple dans votre cas d'appeler la fonction dns_lookup deux fois, récupérer deux listes distinctes et laisser à Django le soin de les afficher.

**Rudeus** · 05/08/2023, 18h03

En effet je pense que le plus simple serait d'appeler deux fois la fonction pour remonter NS et A.

Mais par contre, est il possible d'envoyer deux variables avec render()?

Car, si j'appelle deux fois la fonction comme dans ma vue :

Code :

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

1
2
3
4
5
6
7
8
def onglet_dnslookup(request):
    domain_name = request.POST.get("domain_name")
    try:
        ns = dns_lookup(domain_name, "NS")
        a = dns_lookup(domain_name, "A")
        return render(request, 'toolbox/dnslookup.html', {'a': a}, {"ns" : ns})
    except ValueError:
        return render(request, 'toolbox/dnslookup.html')

Alors Django ne me retournera pas "a" et "ns" lors de l'appel dans mon fichier html.

Il me retourne le fichier html complet dans mon navigateur.

EDIT :

J'ai remplacé return render(request, 'toolbox/dnslookup.html', {'a': a}, {"ns" : ns}) par return render(request, 'toolbox/dnslookup.html', {'a': a ,"ns" : ns}), l'affichage est désormais ok !

Nom : ffichage_ok.jpg
Affichages : 97
Taille : 10,7 Ko

Nom : ffichage_ok.jpg
Affichages : 97
Taille : 10,7 Ko

Il ne me reste plus qu'à trouver un moyen de retirer les crochets et apostrophes !

**binarygirl** · 05/08/2023, 19h01

En Django l'utilisation du simple filtre join suffirait pour formater des listes: https://docs.djangoproject.com/en/de...builtins/#join
On peut aussi faire des boucles si on veut un affichage plus sophistiqué avec <ul><li>Le join peut aussi se faire en amont en Python avant de passer les variables au template, mais je trouve que ça donne plus de souplesse de laisser Django gérer l'affichage. Un jour on voudra peut-être afficher un tableau, alors il suffira juste d'adapter le template mais le code Python ne devra pas changer.

**Rudeus** · 05/08/2023, 19h14

J'étais en train de partir sur le join de Python mais en effet avec celui de Django c'est beaucoup plus simple.

Mon affichage est désormais parfait !

Nom : OK.jpg
Affichages : 97
Taille : 49,2 Ko

Nom : OK.jpg
Affichages : 97
Taille : 49,2 Ko

Un grand merci à vous !

Retour à la ligne impossible

Python

Discussions similaires

Partager

Partager