Ce Python serait vous suggérons de vérifier whois enregistrements de base de données?

Il n'y a rien de mal avec l'aide d'un utilitaire de ligne de commande pour faire ce que vous voulez. Si vous mettez une belle enveloppe le service, vous pouvez mettre en œuvre à l'intérieur comme vous le souhaitez! Par exemple:

class Whois(object):
    _whois_by_query_cache = {}

    def __init__(self, query):
        """Initializes the instance variables to defaults. See :meth:`lookup`
        for details on how to submit the query."""
        self.query = query
        self.domain = None
        # ... other fields.

    def lookup(self):
        """Submits the `whois` query and stores results internally."""
        # ... implementation

Maintenant, si vous roulez votre propre en utilisant urllib, enroulé autour d'un utilitaire de ligne de commande (comme vous le faites), ou de l'importation d'un tiers de la bibliothèque et de l'utiliser (comme vous êtes en train de dire), cette interface reste la même.

Cette approche n'est généralement pas considéré comme laid, parfois de commande utilitaires de faire ce que vous voulez et vous devriez être en mesure de tirer parti de leur. Si la vitesse finit par être un goulot d'étranglement, votre abstraction rend le processus de commutation à un natif de Python de la mise en œuvre transparente à votre code client.

Praticité beats pureté -- c'est ce qui est Pythonic. 🙂

OriginalL'auteur cdleary

Trouve cette question dans le processus de ma propre recherche pour un python whois bibliothèque.

Ne sais pas que je suis d'accord avec cdleary de la réponse que l'utilisation d'une bibliothèque qui s'enroule
une commande est toujours la meilleure façon de le faire - mais je peux voir ses raisons pourquoi il a dit cela.

Pro: cmd-ligne whois gère tout le travail dur (prise d'appels, analyse, etc)

Con: pas portable; module peut ne pas fonctionner en fonction sous-jacente whois de commande.
Plus lent, car l'exécution d'une commande et les plus susceptibles de shell en outre le whois de commande.
Affectés si UNIX (Windows), les différents UNIX, âgés UNIX, ou
âgées whois de commande

Je suis à la recherche d'un whois module qui permet de gérer whois IP recherches et je ne suis pas intéressé pour le codage de mon propre whois client.

Voici les modules que j'ai (légèrement) a essayé de sortir et de plus d'informations à ce sujet:

pywhoisapi:

• Maison: http://code.google.com/p/pywhoisapi/
• Conception: REPOS client qui accède ARIN whois service REST
• Pour: Capable de gérer les adresses IP des recherches
• Inconvénients: être Capable d'extraire des informations à partir des serveurs whois de autres Rir?

BulkWhois

• Maison: http://pypi.python.org/pypi/BulkWhois/0.2.1
• Conception: client telnet accès whois telnet, interface de requête à partir de RIR(?)
• Pour: Capable de gérer les adresses IP des recherches
• Inconvénients: être Capable d'extraire des informations à partir des serveurs whois de autres Rir?

pywhois:

• Maison: http://code.google.com/p/pywhois/
• Conception: REPOS client qui accède RRID services whois
• Pour: Accessses de nombreux RRIDs; a python 3.x branche
• Inconvénients: ne semble pas gérer adresse IP recherches

python-base de données whois:

• Maison: http://code.google.com/p/python-whois/
• Conception: wraps "whois" commande
• Inconvénients: ne semble pas gérer adresse IP recherches

whoisclient - fourchette de python-whois

• Maison: http://gitorious.org/python-whois
• Conception: wraps "whois" commande
• Dépend: IPy.py
• Inconvénients: ne semble pas gérer adresse IP recherches

Mise à jour: j'ai fini par utiliser pywhoisapi pour le reverse IP des recherches que je faisais

OriginalL'auteur Lars Nordin

Je ne sais pas si gwhois fait quelque chose de spécial avec le serveur de sortie; toutefois, vous pouvez simplement vous connecter à la base de données whois server sur le port whois (43), envoyez votre requête, de lire toutes les données dans la réponse et les analyser. Pour rendre la vie un peu plus facile, vous pouvez utiliser le telnetlib.Telnet classe (même si le protocole whois est beaucoup plus simple que le protocole telnet) au lieu de la plaine de sockets.

Les parties difficiles:

• whois server allez-vous demander? MÛR, ARIN, APNIC, LACNIC, AFRINIC, JPNIC, VERIO etc LACNIC pourrait être un utile secours, car ils ont tendance à répondre avec des données utiles à des demandes en dehors de leur domaine.
• quelles sont les options et les arguments pour chaque serveur whois? certains offrent de l'aide, d'autres n'ont pas. En général, la plaine des noms de domaine de travail sans aucune option spéciale.

OriginalL'auteur tzot

L'analyse d'une autre page web woulnd pas aussi mauvais (en supposant que leur code html woulnd pas être très mauvais), mais il serait réellement m'attacher à eux - s'ils sont en bas, je suis en bas 🙂

En fait j'ai trouvé quelques vieux projet sur sourceforge: rwhois.py. Ce qui m'effraie un peu, c'est que leur dernière mise à jour est à partir de 2003. Mais, il peut sembler comme un bon endroit pour commencer la remise à plat de ce que je fais maintenant... eh Bien, je sentais obligued à poster le lien de ce projet de toute façon, juste pour référence ultérieure.

OriginalL'auteur kender

ici est un prêt-à-utiliser la solution qui fonctionne pour moi; écrit en Python 3.1 (lorsque le portage de Py2.x, prenez soin de les octets /texte Unicode distinctions). votre point d'accès unique est la méthode DRWHO.whois(), qui attend un nom de domaine pour être passé; il va alors essayer de résoudre le nom à l'aide du fournisseur configuré comme DRWHO.whois_providers[ '*' ] (une solution plus complète pourrait différencier les fournisseurs selon le domaine de premier niveau). DRWHO.whois() sera de retour un dictionnaire avec une seule entrée text, qui contient le texte de la réponse renvoyée par le serveur WHOIS. Encore une fois, une solution plus complète serait alors essayer et d'analyse du texte (qui doit être effectuée séparément pour chaque fournisseur, il n'y a pas de format standard) et le retour à un format plus structuré (par exemple, définir un indicateur available qui indique si le domaine est disponible). amusez-vous!

##########################################################################
import asyncore as                                   _sys_asyncore
from asyncore import loop as                         _sys_asyncore_loop
import socket as                                     _sys_socket
##########################################################################
class _Whois_request( _sys_asyncore.dispatcher_with_send, object ):
# simple whois requester
# original code by Frederik Lundh
#-----------------------------------------------------------------------
whoisPort = 43
#-----------------------------------------------------------------------
def __init__(self, consumer, host, provider ):
_sys_asyncore.dispatcher_with_send.__init__(self)
self.consumer = consumer
self.query    = host
self.create_socket( _sys_socket.AF_INET, _sys_socket.SOCK_STREAM )
self.connect( ( provider, self.whoisPort, ) )
#-----------------------------------------------------------------------
def handle_connect(self):
self.send( bytes( '%s\r\n' % ( self.query, ), 'utf-8' ) )
#-----------------------------------------------------------------------
def handle_expt(self):
self.close() # connection failed, shutdown
self.consumer.abort()
#-----------------------------------------------------------------------
def handle_read(self):
# get data from server
self.consumer.feed( self.recv( 2048 ) )
#-----------------------------------------------------------------------
def handle_close(self):
self.close()
self.consumer.close()
##########################################################################
class _Whois_consumer( object ):
# original code by Frederik Lundh
#-----------------------------------------------------------------------
def __init__( self, host, provider, result ):
self.texts_as_bytes = []
self.host           = host
self.provider       = provider
self.result         = result
#-----------------------------------------------------------------------
def feed( self, text ):
self.texts_as_bytes.append( text.strip() )
#-----------------------------------------------------------------------
def abort(self):
del self.texts_as_bytes[:]
self.finalize()
#-----------------------------------------------------------------------
def close(self):
self.finalize()
#-----------------------------------------------------------------------
def finalize( self ):
# join bytestrings and decode them (witha a guessed encoding):
text_as_bytes         = b'\n'.join( self.texts_as_bytes )
self.result[ 'text' ] = text_as_bytes.decode( 'utf-8' )
##########################################################################
class DRWHO:
#-----------------------------------------------------------------------
whois_providers = {
'~isa':   'DRWHO/whois-providers',
'*':      'whois.opensrs.net', }
#-----------------------------------------------------------------------
def whois( self, domain ):
R         = {}
provider  = self._get_whois_provider( '*' )
self._fetch_whois( provider, domain, R )
return R
#-----------------------------------------------------------------------
def _get_whois_provider( self, top_level_domain ):
providers = self.whois_providers
R         = providers.get( top_level_domain, None )
if R is None:
R = providers[ '*' ]
return R
#-----------------------------------------------------------------------
def _fetch_whois( self, provider, domain, pod ):
#.....................................................................
consumer  = _Whois_consumer(           domain, provider, pod )
request   = _Whois_request(  consumer, domain, provider )
#.....................................................................
_sys_asyncore_loop() # loops until requests have been processed
#=========================================================================
DRWHO = DRWHO()
domain    = 'example.com'
whois     = DRWHO.whois( domain )
print( whois[ 'text' ] )

OriginalL'auteur flow