Was Python Weg würden Sie vorschlagen, um zu überprüfen, whois-Datenbank Datensätze?

Es ist nichts falsch mit der Verwendung von Befehlszeilen-Dienstprogramm, das zu tun, was Sie wollen. Wenn Sie eine schöne Hülle um den service, die Sie implementieren können, die Interna, aber Sie wollen! Zum Beispiel:

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

Nun, ob oder nicht Sie Rollen Sie Ihre eigenen mit das urllib, wrap-around-ein Befehlszeilen-Dienstprogramm (wie du tust), oder importieren Sie eine Drittanbieter-Bibliothek und verwenden Sie, dass (wie du sagst), das interface bleibt das gleiche.

Dieser Ansatz ist in der Regel nicht als hässlich an alle -- manchmal Dienstprogramme Befehl tun, was Sie wollen, und Sie sollten in der Lage sein, diese zu nutzen. Wenn die Geschwindigkeit am Ende ein Engpass, Ihre Abstraktion macht den Prozess der Umstellung auf eine native Python-Implementierung transparent für Ihre client-code.

Praktikabilität beats Reinheit -- das ist, was Pythonic. 🙂

Fand diese Frage im Zuge meiner eigenen Suche nach einem python whois Bibliothek.

Nicht wissen, dass ich Stimme mit cdleary die Antwort, dass die Verwendung einer Bibliothek, wraps
ein Befehl ist immer der beste Weg zu gehen - aber ich kann sehen, dass seine Gründe, warum er dies sagte.

Pro: cmd-line whois Griffe all die harte Arbeit (socket-Aufrufe, Parsen, etc)

Con: nicht tragbar; - Modul funktioniert möglicherweise nicht, je nach zugrunde liegenden whois-Befehl.
Langsamer, da läuft ein Befehl, und die meisten wahrscheinlich shell zusätzlich zu den whois-Befehl.
Betroffen, wenn nicht UNIX (Windows), verschiedene UNIX -, ältere UNIX, oder
ältere whois-Befehl

Ich bin auf der Suche nach einem whois-Modul kann mit " whois IP-lookups und ich bin nicht daran interessiert, in die Entwicklung meiner eigenen whois-client.

Hier sind die Module, die ich (leicht) ausprobiert und weitere Informationen:

pywhoisapi:

• Home: http://code.google.com/p/pywhoisapi/
• Design: REST-client den Zugriff auf ARIN whois-REST-Dienst
• Vorteile: in der Lage zu handhaben IP-Adresse lookups
• Nachteile: in der Lage zu ziehen die Informationen aus dem whois-Server der anderen RIRs?

BulkWhois

• Home: http://pypi.python.org/pypi/BulkWhois/0.2.1
• Design: telnet-client den Zugriff auf whois-telnet-Abfrage-Schnittstelle von RIR(?)
• Vorteile: in der Lage zu handhaben IP-Adresse lookups
• Nachteile: in der Lage zu ziehen die Informationen aus dem whois-Server der anderen RIRs?

pywhois:

• Home: http://code.google.com/p/pywhois/
• Design: REST-client den Zugriff auf RRID whois-Dienste
• Vorteile: Accessses viele RRIDs; hat python 3.x-Zweig
• Nachteile: scheint nicht zu behandeln IP-Adresse lookups

python-whois:

• Home: http://code.google.com/p/python-whois/
• Design: wraps "whois" - Befehl
• Nachteile: scheint nicht zu behandeln IP-Adresse lookups

whoisclient - Gabel von python-whois

• Home: http://gitorious.org/python-whois
• Design: wraps "whois" - Befehl
• Hängt ab von: IPy.py
• Nachteile: scheint nicht zu behandeln IP-Adresse lookups

Update: ich landete mit pywhoisapi für die reverse IP lookups, dass ich dabei war

Ich weiß nicht, ob gwhois hat etwas besonderes mit der server-Ausgabe; Sie können jedoch einfach eine Verbindung zum whois-server auf port whois (43), senden Sie Ihre Anfrage, Lesen Sie alle Daten in die Antworten und analysieren Sie. Um das Leben ein wenig zu erleichtern, könnten Sie die telnetlib.Die Telnet-Klasse (auch wenn die whois-Protokoll ist viel einfacher als das telnet-Protokoll) anstelle von plain sockets.

Die knifflige Teile:

• die whois-Servers wird Sie Fragen? RIPE, ARIN, APNIC, LACNIC, AFRINIC, JPNIC, VERIO etc LACNIC könnte eine sinnvolle fallback, da Sie dazu neigen, Antworten mit nützlichen Daten zu Anfragen, die außerhalb Ihrer Domäne.
• was sind die genauen Optionen und Argumente für die einzelnen whois-server? manche bieten Hilfe, andere nicht. Im Allgemeinen, plain domain-Namen arbeiten, ohne Besondere Optionen.

Parsen einer anderen Webseite woulnd nicht so schlecht (vorausgesetzt, Ihre html-woulnd nicht sehr schlimm), aber es würde tatsächlich binden mich an Sie - wenn Sie sind unten, ich bin unten 🙂

Tatsächlich fand ich einige alte Projekt auf sourceforge: rwhois.py. Was mich erschreckt ein wenig, dass der Letzte update ist von 2003. Aber, es könnte scheinen, als ein guter Ort, um zu starten Neuimplementierung von dem, was ich jetzt tun... Gut, ich fühlte mich obligued, um den link posten zu diesem Projekt ohnehin nur für eine weitere Referenz.

hier ist ein ready-to-use-Lösung, die funktioniert für mich; geschrieben für Python 3.1 (wenn Zurückportieren zu Py2.x, Besondere Sorgfalt der bytes /Unicode-text-Unterscheidungen). single-point-of-access die Methode ist, die DRWHO.whois(), die erwartet, dass ein domain-name übergeben werden; es wird dann versuchen, den Namen auflösen mithilfe der provider konfiguriert DRWHO.whois_providers[ '*' ] (eine vollständigere Lösung könnte differenzieren die Anbieter nach der top-level-domain). DRWHO.whois() zurückkehren wird ein Wörterbuch mit einer einzigen Eintrag text enthält die Antwort-text geschickt zurück, indem Sie die WHOIS-server. Wieder eine vollständige Lösung würde dann versuchen und analysieren Sie den text (was muss getan werden, separat für jeden Anbieter, da es kein standard-format) und wieder einer mehr, strukturierter Form (z.B. durch setzen eines Flags available die angibt, ob oder nicht, die domain sieht verfügbar). Spaß haben!

##########################################################################
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' ] )