Mini Shell
# -*- coding: utf-8 -*-
# parser.py - Module for parsing whois response data
# Copyright (c) 2008 Andrey Petrov
#
# This module is part of pywhois and is released under
# the MIT license: http://www.opensource.org/licenses/mit-license.php
from __future__ import absolute_import
from __future__ import unicode_literals
from __future__ import print_function
from __future__ import division
from future import standard_library
import re
from datetime import datetime
import json
from past.builtins import basestring
from builtins import str
from builtins import *
standard_library.install_aliases()
try:
import dateutil.parser as dp
from .time_zones import tz_data
DATEUTIL = True
except ImportError:
DATEUTIL = False
EMAIL_REGEX = "[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?"
KNOWN_FORMATS = [
'%d-%b-%Y', # 02-jan-2000
'%d-%B-%Y', # 11-February-2000
'%d-%m-%Y', # 20-10-2000
'%Y-%m-%d', # 2000-01-02
'%d.%m.%Y', # 2.1.2000
'%Y.%m.%d', # 2000.01.02
'%Y/%m/%d', # 2000/01/02
'%Y%m%d', # 20170209
'%d/%m/%Y', # 02/01/2013
'%Y. %m. %d.', # 2000. 01. 02.
'%Y.%m.%d %H:%M:%S', # 2014.03.08 10:28:24
'%d-%b-%Y %H:%M:%S %Z', # 24-Jul-2009 13:20:03 UTC
'%a %b %d %H:%M:%S %Z %Y', # Tue Jun 21 23:59:59 GMT 2011
'%Y-%m-%dT%H:%M:%SZ', # 2007-01-26T19:10:31Z
'%Y-%m-%dT%H:%M:%S.%fZ', # 2018-12-01T16:17:30.568Z
'%Y-%m-%dT%H:%M:%S%z', # 2013-12-06T08:17:22-0800
'%Y-%m-%d %H:%M:%SZ', # 2000-08-22 18:55:20Z
'%Y-%m-%d %H:%M:%S', # 2000-08-22 18:55:20
'%d %b %Y %H:%M:%S', # 08 Apr 2013 05:44:00
'%d/%m/%Y %H:%M:%S', # 23/04/2015 12:00:07 EEST
'%d/%m/%Y %H:%M:%S %Z', # 23/04/2015 12:00:07 EEST
'%d/%m/%Y %H:%M:%S.%f %Z', # 23/04/2015 12:00:07.619546 EEST
'%B %d %Y', # August 14 2017
'%d.%m.%Y %H:%M:%S', # 08.03.2014 10:28:24
]
class PywhoisError(Exception):
pass
def datetime_parse(s):
for known_format in KNOWN_FORMATS:
try:
s = datetime.strptime(s, known_format)
break
except ValueError as e:
pass # Wrong format, keep trying
return s
def cast_date(s, dayfirst=False, yearfirst=False):
"""Convert any date string found in WHOIS to a datetime object.
"""
if DATEUTIL:
try:
return dp.parse(
s,
tzinfos=tz_data,
dayfirst=dayfirst,
yearfirst=yearfirst
).replace(tzinfo=None)
except Exception:
return datetime_parse(s)
else:
return datetime_parse(s)
class WhoisEntry(dict):
"""Base class for parsing a Whois entries.
"""
# regular expressions to extract domain data from whois profile
# child classes will override this
_regex = {
'domain_name': 'Domain Name: *(.+)',
'registrar': 'Registrar: *(.+)',
'whois_server': 'Whois Server: *(.+)',
'referral_url': 'Referral URL: *(.+)', # http url of whois_server
'updated_date': 'Updated Date: *(.+)',
'creation_date': 'Creation Date: *(.+)',
'expiration_date': 'Expir\w+ Date: *(.+)',
'name_servers': 'Name Server: *(.+)', # list of name servers
'status': 'Status: *(.+)', # list of statuses
'emails': EMAIL_REGEX, # list of email s
'dnssec': 'dnssec: *([\S]+)',
'name': 'Registrant Name: *(.+)',
'org': 'Registrant\s*Organization: *(.+)',
'address': 'Registrant Street: *(.+)',
'city': 'Registrant City: *(.+)',
'state': 'Registrant State/Province: *(.+)',
'zipcode': 'Registrant Postal Code: *(.+)',
'country': 'Registrant Country: *(.+)',
}
dayfirst = False
yearfirst = False
def __init__(self, domain, text, regex=None):
if 'This TLD has no whois server, but you can access the whois database at' in text:
raise PywhoisError(text)
else:
self.domain = domain
self.text = text
if regex is not None:
self._regex = regex
self.parse()
def parse(self):
"""The first time an attribute is called it will be calculated here.
The attribute is then set to be accessed directly by subsequent calls.
"""
for attr, regex in list(self._regex.items()):
if regex:
values = []
for data in re.findall(regex, self.text, re.IGNORECASE | re.M):
matches = data if isinstance(data, tuple) else [data]
for value in matches:
value = self._preprocess(attr, value)
if value and value not in values:
# avoid duplicates
values.append(value)
if values and attr in ('registrar', 'whois_server', 'referral_url'):
values = values[-1] # ignore junk
if len(values) == 1:
values = values[0]
elif not values:
values = None
self[attr] = values
def _preprocess(self, attr, value):
value = value.strip()
if value and isinstance(value, basestring) and not value.isdigit() and '_date' in attr:
# try casting to date format
value = cast_date(
value,
dayfirst=self.dayfirst,
yearfirst=self.yearfirst)
return value
def __setitem__(self, name, value):
super(WhoisEntry, self).__setitem__(name, value)
def __getattr__(self, name):
return self.get(name)
def __str__(self):
def handler(e): return str(e)
return json.dumps(self, indent=2, default=handler)
def __getstate__(self):
return self.__dict__
def __setstate__(self, state):
self.__dict__ = state
@staticmethod
def load(domain, text):
"""Given whois output in ``text``, return an instance of ``WhoisEntry``
that represents its parsed contents.
"""
if text.strip() == 'No whois server is known for this kind of object.':
raise PywhoisError(text)
if domain.endswith('.com'):
return WhoisCom(domain, text)
elif domain.endswith('.net'):
return WhoisNet(domain, text)
elif domain.endswith('.org'):
return WhoisOrg(domain, text)
elif domain.endswith('.name'):
return WhoisName(domain, text)
elif domain.endswith('.me'):
return WhoisMe(domain, text)
elif domain.endswith('ae'):
return WhoisAe(domain, text)
elif domain.endswith('.au'):
return WhoisAU(domain, text)
elif domain.endswith('.ru'):
return WhoisRu(domain, text)
elif domain.endswith('.us'):
return WhoisUs(domain, text)
elif domain.endswith('.uk'):
return WhoisUk(domain, text)
elif domain.endswith('.fr'):
return WhoisFr(domain, text)
elif domain.endswith('.nl'):
return WhoisNl(domain, text)
elif domain.endswith('.fi'):
return WhoisFi(domain, text)
elif domain.endswith('.hr'):
return WhoisHr(domain, text)
elif domain.endswith('.hn'):
return WhoisHn(domain, text)
elif domain.endswith('.hk'):
return WhoisHk(domain, text)
elif domain.endswith('.jp'):
return WhoisJp(domain, text)
elif domain.endswith('.pl'):
return WhoisPl(domain, text)
elif domain.endswith('.br'):
return WhoisBr(domain, text)
elif domain.endswith('.eu'):
return WhoisEu(domain, text)
elif domain.endswith('.ee'):
return WhoisEe(domain, text)
elif domain.endswith('.kr'):
return WhoisKr(domain, text)
elif domain.endswith('.pt'):
return WhoisPt(domain, text)
elif domain.endswith('.bg'):
return WhoisBg(domain, text)
elif domain.endswith('.de'):
return WhoisDe(domain, text)
elif domain.endswith('.at'):
return WhoisAt(domain, text)
elif domain.endswith('.ca'):
return WhoisCa(domain, text)
elif domain.endswith('.be'):
return WhoisBe(domain, text)
elif domain.endswith('.рф'):
return WhoisRf(domain, text)
elif domain.endswith('.info'):
return WhoisInfo(domain, text)
elif domain.endswith('.su'):
return WhoisSu(domain, text)
elif domain.endswith('si'):
return WhoisSi(domain, text)
elif domain.endswith('.kg'):
return WhoisKg(domain, text)
elif domain.endswith('.io'):
return WhoisIo(domain, text)
elif domain.endswith('.biz'):
return WhoisBiz(domain, text)
elif domain.endswith('.mobi'):
return WhoisMobi(domain, text)
elif domain.endswith('.ch'):
return WhoisChLi(domain, text)
elif domain.endswith('.li'):
return WhoisChLi(domain, text)
elif domain.endswith('.id'):
return WhoisID(domain, text)
elif domain.endswith('.sk'):
return WhoisSK(domain, text)
elif domain.endswith('.se'):
return WhoisSe(domain, text)
elif domain.endswith('no'):
return WhoisNo(domain, text)
elif domain.endswith('.nu'):
return WhoisSe(domain, text)
elif domain.endswith('.is'):
return WhoisIs(domain, text)
elif domain.endswith('.dk'):
return WhoisDk(domain, text)
elif domain.endswith('.it'):
return WhoisIt(domain, text)
elif domain.endswith('.mx'):
return WhoisMx(domain, text)
elif domain.endswith('.ai'):
return WhoisAi(domain, text)
elif domain.endswith('.il'):
return WhoisIl(domain, text)
elif domain.endswith('.in'):
return WhoisIn(domain, text)
elif domain.endswith('.cat'):
return WhoisCat(domain, text)
elif domain.endswith('.ie'):
return WhoisIe(domain, text)
elif domain.endswith('.nz'):
return WhoisNz(domain, text)
elif domain.endswith('.space'):
return WhoisSpace(domain, text)
elif domain.endswith('.lu'):
return WhoisLu(domain, text)
elif domain.endswith('.cz'):
return WhoisCz(domain, text)
elif domain.endswith('.online'):
return WhoisOnline(domain, text)
elif domain.endswith('.cn'):
return WhoisCn(domain, text)
elif domain.endswith('.app'):
return WhoisApp(domain, text)
elif domain.endswith('.money'):
return WhoisMoney(domain, text)
elif domain.endswith('.cl'):
return WhoisCl(domain, text)
elif domain.endswith('.ar'):
return WhoisAr(domain, text)
elif domain.endswith('.by'):
return WhoisBy(domain, text)
elif domain.endswith('.cr'):
return WhoisCr(domain, text)
elif domain.endswith('.do'):
return WhoisDo(domain, text)
elif domain.endswith('.jobs'):
return WhoisJobs(domain, text)
elif domain.endswith('.lat'):
return WhoisLat(domain, text)
elif domain.endswith('.pe'):
return WhoisPe(domain, text)
elif domain.endswith('.ro'):
return WhoisRo(domain, text)
elif domain.endswith('.sa'):
return WhoisSa(domain, text)
elif domain.endswith('.tw'):
return WhoisTw(domain, text)
elif domain.endswith('.tr'):
return WhoisTr(domain, text)
elif domain.endswith('.ve'):
return WhoisVe(domain, text)
elif domain.endswith('.ua'):
return WhoisUA(domain, text)
elif domain.endswith('.kz'):
return WhoisKZ(domain, text)
else:
return WhoisEntry(domain, text)
class WhoisCl(WhoisEntry):
"""Whois parser for .cl domains."""
regex = {
'domain_name': 'Domain name: *(.+)',
'registrant_name': 'Registrant name: *(.+)',
'registrant_organization': 'Registrant organisation: *(.+)',
'registrar': 'registrar name: *(.+)',
'registrar_url': 'Registrar URL: *(.+)',
'creation_date': 'Creation date: *(.+)',
'expiration_date': 'Expiration date: *(.+)',
'name_servers': 'Name server: *(.+)', # list of name servers
}
def __init__(self, domain, text):
if 'No match for "' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisPe(WhoisEntry):
"""Whois parser for .pe domains."""
regex = {
'domain_name': 'Domain name: *(.+)',
'status': 'Domain Status: *(.+)',
'whois_server': 'WHOIS Server: *(.+)',
'registrant_name': 'Registrant name: *(.+)',
'registrar': 'Sponsoring Registrar: *(.+)',
'admin': 'Admin Name: *(.+)',
'admin_email': 'Admin Email: *(.+)',
'dnssec': 'DNSSEC: *(.+)',
'name_servers': 'Name server: *(.+)', # list of name servers
}
def __init__(self, domain, text):
if 'No match for "' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisSpace(WhoisEntry):
"""Whois parser for .space domains
"""
def __init__(self, domain, text):
if 'No match for "' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text)
class WhoisCom(WhoisEntry):
"""Whois parser for .com domains
"""
def __init__(self, domain, text):
if 'No match for "' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text)
class WhoisNet(WhoisEntry):
"""Whois parser for .net domains
"""
def __init__(self, domain, text):
if 'No match for "' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text)
class WhoisOrg(WhoisEntry):
"""Whois parser for .org domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'registrar': 'Registrar: *(.+)',
'whois_server': 'Whois Server: *(.+)', # empty usually
'referral_url': 'Referral URL: *(.+)', # http url of whois_server: empty usually
'updated_date': 'Updated Date: *(.+)',
'creation_date': 'Creation Date: *(.+)',
'expiration_date': 'Registry Expiry Date: *(.+)',
'name_servers': 'Name Server: *(.+)', # list of name servers
'status': 'Status: *(.+)', # list of statuses
'emails': EMAIL_REGEX, # list of email addresses
}
def __init__(self, domain, text):
if text.strip() == 'NOT FOUND':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text)
class WhoisRo(WhoisEntry):
"""Whois parser for .ro domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'domain_status': 'Domain Status: *(.+)',
'registrar': 'Registrar: *(.+)',
'referral_url': 'Referral URL: *(.+)', # http url of whois_server: empty usually
'creation_date': 'Registered On: *(.+)',
'expiration_date': 'Expires On: *(.+)',
'name_servers': 'Nameserver: *(.+)', # list of name servers
'status': 'Status: *(.+)', # list of statuses
'dnssec': 'DNSSEC: *(.+)',
}
def __init__(self, domain, text):
if text.strip() == 'NOT FOUND':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisRu(WhoisEntry):
"""Whois parser for .ru domains
"""
regex = {
'domain_name': 'domain: *(.+)',
'registrar': 'registrar: *(.+)',
'creation_date': 'created: *(.+)',
'expiration_date': 'paid-till: *(.+)',
'updated_date': None,
'name_servers': 'nserver: *(.+)', # list of name servers
'status': 'state: *(.+)', # list of statuses
'emails': EMAIL_REGEX, # list of email addresses
'org': 'org: *(.+)'
}
def __init__(self, domain, text):
if 'No entries found' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisNl(WhoisEntry):
"""Whois parser for .nl domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'expiration_date': None,
'updated_date': None,
'creation_date': None,
'status': 'Status: *(.+)', # list of statuses
'name': None,
'registrar': 'Registrar:\s*(.*\n)',
'registrar_address': 'Registrar:\s*(?:.*\n){1}\s*(.*)',
'registrar_zip_code': 'Registrar:\s*(?:.*\n){2}\s*(\S*)\s(?:.*)',
'registrar_city': 'Registrar:\s*(?:.*\n){2}\s*(?:\S*)\s(.*)',
'registrar_country': 'Registrar:\s*(?:.*\n){3}\s*(.*)',
'dnssec': 'DNSSEC: *(.+)',
}
def __init__(self, domain, text):
if text.endswith('is free'):
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
match = re.compile('Domain nameservers:(.*?)Record maintained by', re.DOTALL).search(text)
if match:
duplicate_nameservers_with_ip = [line.strip()
for line in match.groups()[0].strip().splitlines()]
duplicate_nameservers_without_ip = [nameserver.split(' ')[0]
for nameserver in duplicate_nameservers_with_ip]
self['name_servers'] = sorted(list(set(duplicate_nameservers_without_ip)))
class WhoisName(WhoisEntry):
"""Whois parser for .name domains
"""
regex = {
'domain_name_id': 'Domain Name ID: *(.+)',
'domain_name': 'Domain Name: *(.+)',
'registrar_id': 'Sponsoring Registrar ID: *(.+)',
'registrar': 'Sponsoring Registrar: *(.+)',
'registrant_id': 'Registrant ID: *(.+)',
'admin_id': 'Admin ID: *(.+)',
'technical_id': 'Tech ID: *(.+)',
'billing_id': 'Billing ID: *(.+)',
'creation_date': 'Created On: *(.+)',
'expiration_date': 'Expires On: *(.+)',
'updated_date': 'Updated On: *(.+)',
'name_server_ids': 'Name Server ID: *(.+)', # list of name server ids
'name_servers': 'Name Server: *(.+)', # list of name servers
'status': 'Domain Status: *(.+)', # list of statuses
}
def __init__(self, domain, text):
if 'No match for ' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisUs(WhoisEntry):
"""Whois parser for .us domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'domain__id': 'Domain ID: *(.+)',
'whois_server': 'Registrar WHOIS Server: *(.+)',
'registrar': 'Registrar: *(.+)',
'registrar_id': 'Registrar IANA ID: *(.+)',
'registrar_url': 'Registrar URL: *(.+)',
'registrar_email': 'Registrar Abuse Contact Email: *(.+)',
'registrar_phone': 'Registrar Abuse Contact Phone: *(.+)',
'status': 'Domain Status: *(.+)', # list of statuses
'registrant_id': 'Registry Registrant ID: *(.+)',
'registrant_name': 'Registrant Name: *(.+)',
'registrant_organization': 'Registrant Organization: *(.+)',
'registrant_street': 'Registrant Street: *(.+)',
'registrant_city': 'Registrant City: *(.+)',
'registrant_state_province': 'Registrant State/Province: *(.+)',
'registrant_postal_code': 'Registrant Postal Code: *(.+)',
'registrant_country': 'Registrant Country: *(.+)',
'registrant_phone': 'Registrant Phone: *(.+)',
'registrant_email': 'Registrant Email: *(.+)',
'registrant_fax': 'Registrant Fax: *(.+)',
'registrant_application_purpose': 'Registrant Application Purpose: *(.+)',
'registrant_nexus_category': 'Registrant Nexus Category: *(.+)',
'admin_id': 'Registry Admin ID: *(.+)',
'admin': 'Admin Name: *(.+)',
'admin_organization': 'Admin Organization: *(.+)',
'admin_street': 'Admin Street: *(.+)',
'admin_city': 'Admin City: *(.+)',
'admin_state_province': 'Admin State/Province: *(.+)',
'admin_postal_code': 'Admin Postal Code: *(.+)',
'admin_country': 'Admin Country: *(.+)',
'admin_phone': 'Admin Phone: *(.+)',
'admin_email': 'Admin Email: *(.+)',
'admin_fax': 'Admin Fax: *(.+)',
'admin_application_purpose': 'Admin Application Purpose: *(.+)',
'admin_nexus_category': 'Admin Nexus Category: *(.+)',
'tech_id': 'Registry Tech ID: *(.+)',
'tech_name': 'Tech Name: *(.+)',
'tech_organization': 'Tech Organization: *(.+)',
'tech_street': 'Tech Street: *(.+)',
'tech_city': 'Tech City: *(.+)',
'tech_state_province': 'Tech State/Province: *(.+)',
'tech_postal_code': 'Tech Postal Code: *(.+)',
'tech_country': 'Tech Country: *(.+)',
'tech_phone': 'Tech Phone: *(.+)',
'tech_email': 'Tech Email: *(.+)',
'tech_fax': 'Tech Fax: *(.+)',
'tech_application_purpose': 'Tech Application Purpose: *(.+)',
'tech_nexus_category': 'Tech Nexus Category: *(.+)',
'name_servers': 'Name Server: *(.+)', # list of name servers
'creation_date': 'Creation Date: *(.+)',
'expiration_date': 'Registry Expiry Date: *(.+)',
'updated_date': 'Updated Date: *(.+)',
}
def __init__(self, domain, text):
if 'Not found:' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisPl(WhoisEntry):
"""Whois parser for .pl domains
"""
regex = {
'domain_name': 'DOMAIN NAME: *(.+)\n',
'name_servers': 'nameservers:((?:\s+.+\n+)*)',
'registrar': 'REGISTRAR:\s*(.+)',
'registrar_url': 'URL: *(.+)', # not available
'status': 'Registration status:\n\s*(.+)', # not available
'registrant_name': 'Registrant:\n\s*(.+)', # not available
'creation_date': '(?<! )created: *(.+)\n',
'expiration_date': 'renewal date: *(.+)',
'updated_date': 'last modified: *(.+)\n',
}
def __init__(self, domain, text):
if 'No information available about domain name' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisCa(WhoisEntry):
"""Whois parser for .ca domains
"""
regex = {
'domain_name': 'Domain name: *(.+)',
'whois_server': 'Registrar WHOIS Server: *(.+)',
'registrar': 'Registrar: *(.+)',
'registrar_url': 'Registrar URL: *(.+)',
'registrant_name': 'Registrant Name: *(.+)',
'registrant_number': 'Registry Registrant ID: *(.+)',
'admin_name': 'Admin Name: *(.+)',
'domain_status': 'Domain status: *(.+)',
'emails': 'Email: *(.+)',
'updated_date': 'Updated Date: *(.+)',
'creation_date': 'Creation Date: *(.+)',
'expiration_date': 'Expiry Date: *(.+)',
'phone': 'Phone: *(.+)',
'fax': 'Fax: *(.+)',
'dnssec': 'dnssec: *([\S]+)'
}
def __init__(self, domain, text):
if 'Domain status: available' in text or 'Not found:' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisMe(WhoisEntry):
"""Whois parser for .me domains
"""
regex = {
'domain_id': 'Registry Domain ID:(.+)',
'domain_name': 'Domain Name:(.+)',
'creation_date': 'Creation Date:(.+)',
'updated_date': 'Updated Date:(.+)',
'expiration_date': 'Registry Expiry Date: (.+)',
'registrar': 'Registrar:(.+)',
'status': 'Domain Status:(.+)', # list of statuses
'registrant_id': 'Registrant ID:(.+)',
'registrant_name': 'Registrant Name:(.+)',
'registrant_org': 'Registrant Organization:(.+)',
'registrant_address': 'Registrant Address:(.+)',
'registrant_address2': 'Registrant Address2:(.+)',
'registrant_address3': 'Registrant Address3:(.+)',
'registrant_city': 'Registrant City:(.+)',
'registrant_state_province': 'Registrant State/Province:(.+)',
'registrant_country': 'Registrant Country/Economy:(.+)',
'registrant_postal_code': 'Registrant Postal Code:(.+)',
'registrant_phone': 'Registrant Phone:(.+)',
'registrant_phone_ext': 'Registrant Phone Ext\.:(.+)',
'registrant_fax': 'Registrant FAX:(.+)',
'registrant_fax_ext': 'Registrant FAX Ext\.:(.+)',
'registrant_email': 'Registrant E-mail:(.+)',
'admin_id': 'Admin ID:(.+)',
'admin_name': 'Admin Name:(.+)',
'admin_org': 'Admin Organization:(.+)',
'admin_address': 'Admin Address:(.+)',
'admin_address2': 'Admin Address2:(.+)',
'admin_address3': 'Admin Address3:(.+)',
'admin_city': 'Admin City:(.+)',
'admin_state_province': 'Admin State/Province:(.+)',
'admin_country': 'Admin Country/Economy:(.+)',
'admin_postal_code': 'Admin Postal Code:(.+)',
'admin_phone': 'Admin Phone:(.+)',
'admin_phone_ext': 'Admin Phone Ext\.:(.+)',
'admin_fax': 'Admin FAX:(.+)',
'admin_fax_ext': 'Admin FAX Ext\.:(.+)',
'admin_email': 'Admin E-mail:(.+)',
'tech_id': 'Tech ID:(.+)',
'tech_name': 'Tech Name:(.+)',
'tech_org': 'Tech Organization:(.+)',
'tech_address': 'Tech Address:(.+)',
'tech_address2': 'Tech Address2:(.+)',
'tech_address3': 'Tech Address3:(.+)',
'tech_city': 'Tech City:(.+)',
'tech_state_province': 'Tech State/Province:(.+)',
'tech_country': 'Tech Country/Economy:(.+)',
'tech_postal_code': 'Tech Postal Code:(.+)',
'tech_phone': 'Tech Phone:(.+)',
'tech_phone_ext': 'Tech Phone Ext\.:(.+)',
'tech_fax': 'Tech FAX:(.+)',
'tech_fax_ext': 'Tech FAX Ext\.:(.+)',
'tech_email': 'Tech E-mail:(.+)',
'name_servers': 'Nameservers:(.+)', # list of name servers
}
def __init__(self, domain, text):
if 'NOT FOUND' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisUk(WhoisEntry):
"""Whois parser for .uk domains
"""
regex = {
'domain_name': 'Domain name:\s*(.+)',
'registrar': 'Registrar:\s*(.+)',
'registrar_url': 'URL:\s*(.+)',
'status': 'Registration status:\s*(.+)', # list of statuses
'registrant_name': 'Registrant:\s*(.+)',
'registrant_type': 'Registrant type:\s*(.+)',
'registrant_street': 'Registrant\'s address:\s*(?:.*\n){2}\s+(.*)',
'registrant_city': 'Registrant\'s address:\s*(?:.*\n){3}\s+(.*)',
'registrant_country': 'Registrant\'s address:\s*(?:.*\n){5}\s+(.*)',
'creation_date': 'Registered on:\s*(.+)',
'expiration_date': 'Expiry date:\s*(.+)',
'updated_date': 'Last updated:\s*(.+)',
'name_servers': 'Name servers:\s*(.+)',
}
def __init__(self, domain, text):
if 'No match for ' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisFr(WhoisEntry):
"""Whois parser for .fr domains
"""
regex = {
'domain_name': 'domain: *(.+)',
'registrar': 'registrar: *(.+)',
'creation_date': 'created: *(.+)',
'expiration_date': 'Expir\w+ Date:\s?(.+)',
'name_servers': 'nserver: *(.+)', # list of name servers
'status': 'status: *(.+)', # list of statuses
'emails': EMAIL_REGEX, # list of email addresses
'updated_date': 'last-update: *(.+)',
}
def __init__(self, domain, text):
if 'No entries found' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisFi(WhoisEntry):
"""Whois parser for .fi domains
"""
regex = {
'domain_name': 'domain\.*: *([\S]+)',
'name': 'Holder\s*name\.*:([\S\ ]+)',
'address': '[Holder\w\W]address\.*: ([\S\ ]+)',
'phone': 'Holder[\s\w\W]+phone\.*: ([\S]+)',
'email': 'holder email\.*: *([\S\ ]+)',
'status': 'status\.*: *([\S]+)', # list of statuses
'creation_date': 'created\.*: *([\S]+)',
'updated_date': 'modified\.*: *([\S]+)',
'expiration_date': 'expires\.*: *([\S]+)',
'name_servers': 'nserver\.*: *([\S]+) \[\S+\]', # list of name servers
'name_server_statuses': 'nserver\.*: *([\S]+ \[\S+\])', # list of name servers and statuses
'dnssec': 'dnssec\.*: *([\S]+)',
'registrar': 'Registrar\s*registrar\.*: *([\S]+)',
'registrar_site': 'Registrar[\s\w\W]+www\.*: *([\S]+)'
}
def __init__(self, domain, text):
if 'Domain not ' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisJp(WhoisEntry):
"""Whois parser for .jp domains
"""
regex = {
'domain_name': 'a\. \[Domain Name\]\s*(.+)',
'registrant_org': 'g\. \[Organization\](.+)',
'creation_date': r'\[Registered Date\]\s*(.+)',
'name_servers': 'p\. \[Name Server\]\s*(.+)', # list of name servers
'updated_date': '\[Last Update\]\s?(.+)',
'status': '\[State\]\s*(.+)', # list of statuses
}
def __init__(self, domain, text):
if 'No match!!' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisAU(WhoisEntry):
"""Whois parser for .au domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)\n',
'updated_date': 'Last Modified: *(.+)\n',
'registrar': 'Registrar Name: *(.+)\n',
'status': 'Status: *(.+)',
'registrant_name': 'Registrant: *(.+)',
'registrant_contact_name': 'Registrant Contact Name: (.+)',
'name_servers': 'Name Server: *(.+)',
}
def __init__(self, domain, text):
if text.strip() == 'No Data Found':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisEu(WhoisEntry):
"""Whois parser for .eu domains
"""
regex = {
'domain_name': r'Domain: *([^\n\r]+)',
'tech_name': r'Technical: *Name: *([^\n\r]+)',
'tech_org': r'Technical: *Name: *[^\n\r]+\s*Organisation: *([^\n\r]+)',
'tech_phone': r'Technical: *Name: *[^\n\r]+\s*Organisation: *[^\n\r]+\s*Language: *[^\n\r]+\s*Phone: *([^\n\r]+)',
'tech_fax': r'Technical: *Name: *[^\n\r]+\s*Organisation: *[^\n\r]+\s*Language: *[^\n\r]+\s*Phone: *[^\n\r]+\s*Fax: *([^\n\r]+)',
'tech_email': r'Technical: *Name: *[^\n\r]+\s*Organisation: *[^\n\r]+\s*Language: *[^\n\r]+\s*Phone: *[^\n\r]+\s*Fax: *[^\n\r]+\s*Email: *([^\n\r]+)',
'registrar': r'Registrar: *Name: *([^\n\r]+)',
'name_servers': r'Name servers:\s*(.+)', # list of name servers
}
def __init__(self, domain, text):
if text.strip() == 'Status: AVAILABLE':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisEe(WhoisEntry):
"""Whois parser for .ee domains
"""
regex = {
'domain_name': r'Domain: *[\n\r]+\s*name: *([^\n\r]+)',
'status': r'Domain: *[\n\r]+\s*name: *[^\n\r]+\sstatus: *([^\n\r]+)',
'creation_date': r'Domain: *[\n\r]+\s*name: *[^\n\r]+\sstatus: *[^\n\r]+\sregistered: *([^\n\r]+)',
'updated_date': r'Domain: *[\n\r]+\s*name: *[^\n\r]+\sstatus: *[^\n\r]+\sregistered: *[^\n\r]+\schanged: *([^\n\r]+)',
'expiration_date': r'Domain: *[\n\r]+\s*name: *[^\n\r]+\sstatus: *[^\n\r]+\sregistered: *[^\n\r]+\schanged: *[^\n\r]+\sexpire: *([^\n\r]+)',
# 'tech_name': r'Technical: *Name: *([^\n\r]+)',
# 'tech_org': r'Technical: *Name: *[^\n\r]+\s*Organisation: *([^\n\r]+)',
# 'tech_phone': r'Technical: *Name: *[^\n\r]+\s*Organisation: *[^\n\r]+\s*Language: *[^\n\r]+\s*Phone: *([^\n\r]+)',
# 'tech_fax': r'Technical: *Name: *[^\n\r]+\s*Organisation: *[^\n\r]+\s*Language: *[^\n\r]+\s*Phone: *[^\n\r]+\s*Fax: *([^\n\r]+)',
# 'tech_email': r'Technical: *Name: *[^\n\r]+\s*Organisation: *[^\n\r]+\s*Language: *[^\n\r]+\s*Phone: *[^\n\r]+\s*Fax: *[^\n\r]+\s*Email: *([^\n\r]+)',
'registrar': r'Registrar: *[\n\r]+\s*name: *([^\n\r]+)',
'name_servers': r'nserver: *(.*)', # list of name servers
}
def __init__(self, domain, text):
if text.strip() == 'Domain not found':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisBr(WhoisEntry):
"""Whois parser for .br domains
"""
regex = {
'domain_name': 'domain: *(.+)\n',
'registrant_name': 'owner: *([\S ]+)',
'registrant_id': 'ownerid: *(.+)',
'country': 'country: *(.+)',
'owner_c': 'owner-c: *(.+)',
'admin_c': 'admin-c: *(.+)',
'tech_c': 'tech-c: *(.+)',
'billing_c': 'billing-c: *(.+)',
'name_server': 'nserver: *(.+)',
'nsstat': 'nsstat: *(.+)',
'nslastaa': 'nslastaa: *(.+)',
'saci': 'saci: *(.+)',
'creation_date': 'created: *(.+)',
'updated_date': 'changed: *(.+)',
'expiration_date': 'expires: *(.+)',
'status': 'status: *(.+)',
'nic_hdl_br': 'nic-hdl-br: *(.+)',
'person': 'person: *([\S ]+)',
'email': 'e-mail: *(.+)',
}
def __init__(self, domain, text):
if 'Not found:' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
def _preprocess(self, attr, value):
value = value.strip()
if value and isinstance(value, basestring) and '_date' in attr:
# try casting to date format
value = re.findall(r"[\w\s:.-\\/]+", value)[0].strip()
value = cast_date(
value,
dayfirst=self.dayfirst,
yearfirst=self.yearfirst)
return value
class WhoisKr(WhoisEntry):
"""Whois parser for .kr domains
"""
regex = {
'domain_name': 'Domain Name\s*: *(.+)',
'registrant_name': 'Registrant\s*: *(.+)',
'registrant_address': 'Registrant Address\s*: *(.+)',
'registrant_zip': 'Registrant Zip Code\s*: *(.+)',
'admin_name': 'Administrative Contact\(AC\)\s*: *(.+)',
'admin_email': 'AC E-Mail\s*: *(.+)',
'admin_phone': 'AC Phone Number\s*: *(.+)',
'creation_date': 'Registered Date\s*: *(.+)',
'updated_date': 'Last updated Date\s*: *(.+)',
'expiration_date': 'Expiration Date\s*: *(.+)',
'registrar': 'Authorized Agency\s*: *(.+)',
'name_servers': 'Host Name\s*: *(.+)', # list of name servers
}
def __init__(self, domain, text):
if text.endswith(' no match'):
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisPt(WhoisEntry):
"""Whois parser for .pt domains
"""
regex = {
'domain_name': 'Domain: *(.+)',
'creation_date': 'Creation Date: *(.+)',
'expiration_date': 'Expiration Date: *(.+)',
'registrant_name': 'Owner Name: *(.+)',
'registrant_street': 'Owner Address: *(.+)',
'registrant_city': 'Owner Locality: *(.+)',
'registrant_postal_code': 'Owner ZipCode: *(.+)',
'registrant_email': 'Owner Email: *(.+)',
'admin': 'Admin Name: *(.+)',
'admin_street': 'Admin Address: *(.+)',
'admin_city': 'Admin Locality: *(.+)',
'admin_postal_code':'Admin ZipCode: *(.+)',
'admin_email': 'Admin Email: *(.+)',
'name_servers': 'Name Server: *(.+) \|', # list of name servers
'status': 'Domain Status: *(.+)', # list of statuses
'emails': EMAIL_REGEX, # list of email addresses
}
dayfirst = True
def __init__(self, domain, text):
if text.strip() == 'No entries found':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisBg(WhoisEntry):
"""Whois parser for .bg domains
"""
regex = {
'domain_name': 'DOMAIN NAME: *(.+)\n',
'status': 'registration status: s*(.+)',
'expiration_date': 'expires at: *(.+)',
}
dayfirst = True
def __init__(self, domain, text):
if 'does not exist in database!' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisDe(WhoisEntry):
"""Whois parser for .de domains
"""
regex = {
'domain_name': 'Domain: *(.+)',
'status': 'Status: *(.+)',
'updated_date': 'Changed: *(.+)',
'name': 'name: *(.+)',
'org': 'Organisation: *(.+)',
'address': 'Address: *(.+)',
'zipcode': 'PostalCode: *(.+)',
'city': 'City: *(.+)',
'country_code': 'CountryCode: *(.+)',
'phone': 'Phone: *(.+)',
'fax': 'Fax: *(.+)',
'name_servers': 'Nserver: *(.+)', # list of name servers
'emails': EMAIL_REGEX # list of email addresses
}
def __init__(self, domain, text):
if 'Status: free' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisAt(WhoisEntry):
"""Whois parser for .at domains
"""
regex = {
'domain_name': 'domain: *(.+)',
'registrar': 'registrar: *(.+)',
'name': 'personname: *(.+)',
'org': 'organization: *(.+)',
'address': 'street address: *(.+)',
'zipcode': 'postal code: *(.+)',
'city': 'city: *(.+)',
'country': 'country: *(.+)',
'phone': 'phone: *(.+)',
'fax': 'fax-no: *(.+)',
'updated_date': 'changed: *(.+)',
'email': 'e-mail: *(.+)',
}
def __init__(self, domain, text):
if 'Status: free' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisBe(WhoisEntry):
"""Whois parser for .be domains
"""
regex = {
'name': 'Name: *(.+)',
'org': 'Organisation: *(.+)',
'phone': 'Phone: *(.+)',
'fax': 'Fax: *(.+)',
'email': 'Email: *(.+)',
}
def __init__(self, domain, text):
if 'Status: AVAILABLE' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisInfo(WhoisEntry):
"""Whois parser for .info domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'registrar': 'Registrar: *(.+)',
'whois_server': 'Whois Server: *(.+)', # empty usually
'referral_url': 'Referral URL: *(.+)', # http url of whois_server: empty usually
'updated_date': 'Updated Date: *(.+)',
'creation_date': 'Creation Date: *(.+)',
'expiration_date': 'Registry Expiry Date: *(.+)',
'name_servers': 'Name Server: *(.+)', # list of name servers
'status': 'Status: *(.+)', # list of statuses
'emails': EMAIL_REGEX, # list of email addresses
'name': 'Registrant Name: *(.+)',
'org': 'Registrant Organization: *(.+)',
'address': 'Registrant Street: *(.+)',
'city': 'Registrant City: *(.+)',
'state': 'Registrant State/Province: *(.+)',
'zipcode': 'Registrant Postal Code: *(.+)',
'country': 'Registrant Country: *(.+)',
}
def __init__(self, domain, text):
if text.strip() == 'NOT FOUND':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisRf(WhoisRu):
"""Whois parser for .su domains
"""
def __init__(self, domain, text):
WhoisRu.__init__(self, domain, text)
class WhoisSu(WhoisRu):
"""Whois parser for .su domains
"""
def __init__(self, domain, text):
WhoisRu.__init__(self, domain, text)
class WhoisClub(WhoisEntry):
"""Whois parser for .us domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'domain__id': 'Domain ID: *(.+)',
'registrar': 'Sponsoring Registrar: *(.+)',
'registrar_id': 'Sponsoring Registrar IANA ID: *(.+)',
'registrar_url': 'Registrar URL \(registration services\): *(.+)',
# list of statuses
'status': 'Domain Status: *(.+)',
'registrant_id': 'Registrant ID: *(.+)',
'registrant_name': 'Registrant Name: *(.+)',
'registrant_address1': 'Registrant Address1: *(.+)',
'registrant_address2': 'Registrant Address2: *(.+)',
'registrant_city': 'Registrant City: *(.+)',
'registrant_state_province': 'Registrant State/Province: *(.+)',
'registrant_postal_code': 'Registrant Postal Code: *(.+)',
'registrant_country': 'Registrant Country: *(.+)',
'registrant_country_code': 'Registrant Country Code: *(.+)',
'registrant_phone_number': 'Registrant Phone Number: *(.+)',
'registrant_email': 'Registrant Email: *(.+)',
'registrant_application_purpose': 'Registrant Application Purpose: *(.+)',
'registrant_nexus_category': 'Registrant Nexus Category: *(.+)',
'admin_id': 'Administrative Contact ID: *(.+)',
'admin_name': 'Administrative Contact Name: *(.+)',
'admin_address1': 'Administrative Contact Address1: *(.+)',
'admin_address2': 'Administrative Contact Address2: *(.+)',
'admin_city': 'Administrative Contact City: *(.+)',
'admin_state_province': 'Administrative Contact State/Province: *(.+)',
'admin_postal_code': 'Administrative Contact Postal Code: *(.+)',
'admin_country': 'Administrative Contact Country: *(.+)',
'admin_country_code': 'Administrative Contact Country Code: *(.+)',
'admin_phone_number': 'Administrative Contact Phone Number: *(.+)',
'admin_email': 'Administrative Contact Email: *(.+)',
'admin_application_purpose': 'Administrative Application Purpose: *(.+)',
'admin_nexus_category': 'Administrative Nexus Category: *(.+)',
'billing_id': 'Billing Contact ID: *(.+)',
'billing_name': 'Billing Contact Name: *(.+)',
'billing_address1': 'Billing Contact Address1: *(.+)',
'billing_address2': 'Billing Contact Address2: *(.+)',
'billing_city': 'Billing Contact City: *(.+)',
'billing_state_province': 'Billing Contact State/Province: *(.+)',
'billing_postal_code': 'Billing Contact Postal Code: *(.+)',
'billing_country': 'Billing Contact Country: *(.+)',
'billing_country_code': 'Billing Contact Country Code: *(.+)',
'billing_phone_number': 'Billing Contact Phone Number: *(.+)',
'billing_email': 'Billing Contact Email: *(.+)',
'billing_application_purpose': 'Billing Application Purpose: *(.+)',
'billing_nexus_category': 'Billing Nexus Category: *(.+)',
'tech_id': 'Technical Contact ID: *(.+)',
'tech_name': 'Technical Contact Name: *(.+)',
'tech_address1': 'Technical Contact Address1: *(.+)',
'tech_address2': 'Technical Contact Address2: *(.+)',
'tech_city': 'Technical Contact City: *(.+)',
'tech_state_province': 'Technical Contact State/Province: *(.+)',
'tech_postal_code': 'Technical Contact Postal Code: *(.+)',
'tech_country': 'Technical Contact Country: *(.+)',
'tech_country_code': 'Technical Contact Country Code: *(.+)',
'tech_phone_number': 'Technical Contact Phone Number: *(.+)',
'tech_email': 'Technical Contact Email: *(.+)',
'tech_application_purpose': 'Technical Application Purpose: *(.+)',
'tech_nexus_category': 'Technical Nexus Category: *(.+)',
# list of name servers
'name_servers': 'Name Server: *(.+)',
'created_by_registrar': 'Created by Registrar: *(.+)',
'last_updated_by_registrar': 'Last Updated by Registrar: *(.+)',
'creation_date': 'Domain Registration Date: *(.+)',
'expiration_date': 'Domain Expiration Date: *(.+)',
'updated_date': 'Domain Last Updated Date: *(.+)',
}
def __init__(self, domain, text):
if 'Not found:' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisIo(WhoisEntry):
"""Whois parser for .io domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'domain__id': 'Registry Domain ID: *(.+)',
'registrar': 'Registrar: *(.+)',
'registrar_id': 'Registrar IANA ID: *(.+)',
'registrar_url': 'Registrar URL: *(.+)',
'status': 'Domain Status: *(.+)',
'registrant_name': 'Registrant Organization: *(.+)',
'registrant_state_province': 'Registrant State/Province: *(.+)',
'registrant_country': 'Registrant Country: *(.+)',
'name_servers': 'Name Server: *(.+)',
'creation_date': 'Creation Date: *(.+)',
'expiration_date': 'Registry Expiry Date: *(.+)',
'updated_date': 'Updated Date: *(.+)',
}
def __init__(self, domain, text):
if 'is available for purchase' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisBiz(WhoisEntry):
"""Whois parser for .biz domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'domain__id': 'Domain ID: *(.+)',
'registrar': 'Registrar: *(.+)',
'registrar_url': 'Registrar URL: *(.+)',
'registrar_id': 'Registrar IANA ID: *(.+)',
'registrar_email': 'Registrar Abuse Contact Email: *(.+)',
'registrar_phone': 'Registrar Abuse Contact Phone: *(.+)',
'status': 'Domain Status: *(.+)', # list of statuses
'registrant_id': 'Registrant ID: *(.+)',
'registrant_name': 'Registrant Name: *(.+)',
'registrant_address': 'Registrant Street: *(.+)',
'registrant_city': 'Registrant City: *(.+)',
'registrant_state_province': 'Registrant State/Province: *(.+)',
'registrant_postal_code': 'Registrant Postal Code: *(.+)',
'registrant_country': 'Registrant Country: *(.+)',
'registrant_country_code': 'Registrant Country Code: *(.+)',
'registrant_phone_number': 'Registrant Phone: *(.+)',
'registrant_email': 'Registrant Email: *(.+)',
'admin_id': 'Registry Admin ID: *(.+)',
'admin_name': 'Admin Name: *(.+)',
'admin_organization': 'Admin Organization: *(.+)',
'admin_address': 'Admin Street: *(.+)',
'admin_city': 'Admin City: *(.+)',
'admin_state_province': 'Admin State/Province: *(.+)',
'admin_postal_code': 'Admin Postal Code: *(.+)',
'admin_country': 'Admin Country: *(.+)',
'admin_phone_number': 'Admin Phone: *(.+)',
'admin_email': 'Admin Email: *(.+)',
'tech_id': 'Registry Tech ID: *(.+)',
'tech_name': 'Tech Name: *(.+)',
'tech_organization': 'Tech Organization: *(.+)',
'tech_address': 'Tech Street: *(.+)',
'tech_city': 'Tech City: *(.+)',
'tech_state_province': 'Tech State/Province: *(.+)',
'tech_postal_code': 'Tech Postal Code: *(.+)',
'tech_country': 'Tech Country: *(.+)',
'tech_phone_number': 'Tech Phone: *(.+)',
'tech_email': 'Tech Email: *(.+)',
'name_servers': 'Name Server: *(.+)', # list of name servers
'creation_date': 'Creation Date: *(.+)',
'expiration_date': 'Registrar Registration Expiration Date: *(.+)',
'updated_date': 'Updated Date: *(.+)',
}
def __init__(self, domain, text):
if 'No Data Found' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisMobi(WhoisMe):
"""Whois parser for .mobi domains
"""
def __init__(self, domain, text):
WhoisMe.__init__(self, domain, text)
class WhoisKg(WhoisEntry):
"""Whois parser for .kg domains
"""
regex = {
'domain_name': 'Domain\s*([\w]+\.[\w]{2,5})',
'registrar': 'Domain support: \s*(.+)',
'registrant_name': 'Name: *(.+)',
'registrant_address': 'Address: *(.+)',
'registrant_phone_number': 'phone: *(.+)',
'registrant_email': 'Email: *(.+)',
# # list of name servers
'name_servers': 'Name servers in the listed order: *([\d\w\.\s]+)',
# 'name_servers': r'([\w]+\.[\w]+\.[\w]{2,5}\s*\d{1,3}\.\d]{1,3}\.[\d]{1-3}\.[\d]{1-3})',
'creation_date': 'Record created: *(.+)',
'expiration_date': 'Record expires on \s*(.+)',
'updated_date': 'Record last updated on\s*(.+)',
}
def __init__(self, domain, text):
if 'Data not found. This domain is available for registration' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisChLi(WhoisEntry):
"""Whois Parser for .ch and .li domains
"""
regex = {
'domain_name': '\nDomain name:\n*(.+)',
'registrant_name': 'Holder of domain name:\s*(?:.*\n){1}\s*(.+)',
'registrant_address': 'Holder of domain name:\s*(?:.*\n){2}\s*(.+)',
'registrar': 'Registrar:\n*(.+)',
'creation_date': 'First registration date:\n*(.+)',
'dnssec': 'DNSSEC:*([\S]+)',
'tech-c': 'Technical contact:\n*([\n\s\S]+)\nRegistrar:',
'name_servers': 'Name servers:\n *([\n\S\s]+)'
}
def __init__(self, domain, text):
if 'We do not have an entry in our database matching your query.' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisID(WhoisEntry):
"""Whois parser for .id domains
"""
regex = {
'domain_id': 'Domain ID:(.+)',
'domain_name': 'Domain Name:(.+)',
'creation_date': 'Created On:(.+)',
'expiration_date': 'Expiration Date:(.+)',
'updated_date': 'Last Updated On:(.+)',
'dnssec': 'DNSSEC:(.+)',
'registrar': 'Sponsoring Registrar Organization:(.+)',
'registrar_city': 'Sponsoring Registrar City:(.+)',
'registrar_postal_code': 'Sponsoring Registrar Postal Code:(.+)',
'registrar_country': 'Sponsoring Registrar Country:(.+)',
'registrar_phone': 'Sponsoring Registrar Phone:(.+)',
'registrar_email': 'Sponsoring Registrar Contact Email:(.+)',
'status': 'Status:(.+)', # list of statuses
'registrant_id': 'Registrant ID:(.+)',
'registrant_name': 'Registrant Name:(.+)',
'registrant_org': 'Registrant Organization:(.+)',
'registrant_address': 'Registrant Street1:(.+)',
'registrant_address2': 'Registrant Street2:(.+)',
'registrant_address3': 'Registrant Street3:(.+)',
'registrant_city': 'Registrant City:(.+)',
'registrant_country': 'Registrant Country:(.+)',
'registrant_postal_code': 'Registrant Postal Code:(.+)',
'registrant_phone': 'Registrant Phone:(.+)',
'registrant_fax': 'Registrant FAX:(.+)',
'registrant_email': 'Registrant Email:(.+)',
'name_servers': 'Name Server:(.+)', # list of name servers
}
def __init__(self, domain, text):
if 'NOT FOUND' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisSe(WhoisEntry):
"""Whois parser for .se domains
"""
regex = {
'domain_name': 'domain\.*: *(.+)',
'registrant_name': 'holder\.*: *(.+)',
'creation_date': 'created\.*: *(.+)',
'updated_date': 'modified\.*: *(.+)',
'expiration_date': 'expires\.*: *(.+)',
'transfer_date': 'transferred\.*: *(.+)',
'name_servers': 'nserver\.*: *(.+)', # list of name servers
'dnssec': 'dnssec\.*: *(.+)',
'status': 'status\.*: *(.+)', # list of statuses
'registrar': 'registrar: *(.+)',
}
def __init__(self, domain, text):
if 'not found.' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisJobs(WhoisEntry):
"""Whois parser for .jobs domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'domain_id': 'Registry Domain ID: *(.+)',
'status': 'Domain Status: *(.+)',
'whois_server': 'Registrar WHOIS Server: *(.+)',
'registrar_url': 'Registrar URL: *(.+)',
'registrar_name': 'Registrar: *(.+)',
'registrar_email': 'Registrar Abuse Contact Email: *(.+)',
'registrar_phone': 'Registrar Abuse Contact Phone: *(.+)',
'registrant_name': 'Registrant Name: (.+)',
'registrant_id': 'Registry Registrant ID: (.+)',
'registrant_organization': 'Registrant Organization: (.+)',
'registrant_city': 'Registrant City: (.*)',
'registrant_street': 'Registrant Street: (.*)',
'registrant_state_province': 'Registrant State/Province: (.*)',
'registrant_postal_code': 'Registrant Postal Code: (.*)',
'registrant_country': 'Registrant Country: (.+)',
'registrant_phone': 'Registrant Phone: (.+)',
'registrant_fax': 'Registrant Fax: (.+)',
'registrant_email': 'Registrant Email: (.+)',
'admin_name': 'Admin Name: (.+)',
'admin_id': 'Registry Admin ID: (.+)',
'admin_organization': 'Admin Organization: (.+)',
'admin_city': 'Admin City: (.*)',
'admin_street': 'Admin Street: (.*)',
'admin_state_province': 'Admin State/Province: (.*)',
'admin_postal_code': 'Admin Postal Code: (.*)',
'admin_country': 'Admin Country: (.+)',
'admin_phone': 'Admin Phone: (.+)',
'admin_fax': 'Admin Fax: (.+)',
'admin_email': 'Admin Email: (.+)',
'billing_name': 'Billing Name: (.+)',
'billing_id': 'Registry Billing ID: (.+)',
'billing_organization': 'Billing Organization: (.+)',
'billing_city': 'Billing City: (.*)',
'billing_street': 'Billing Street: (.*)',
'billing_state_province': 'Billing State/Province: (.*)',
'billing_postal_code': 'Billing Postal Code: (.*)',
'billing_country': 'Billing Country: (.+)',
'billing_phone': 'Billing Phone: (.+)',
'billing_fax': 'Billing Fax: (.+)',
'billing_email': 'Billing Email: (.+)',
'tech_name': 'Tech Name: (.+)',
'tech_id': 'Registry Tech ID: (.+)',
'tech_organization': 'Tech Organization: (.+)',
'tech_city': 'Tech City: (.*)',
'tech_street': 'Tech Street: (.*)',
'tech_state_province': 'Tech State/Province: (.*)',
'tech_postal_code': 'Tech Postal Code: (.*)',
'tech_country': 'Tech Country: (.+)',
'tech_phone': 'Tech Phone: (.+)',
'tech_fax': 'Tech Fax: (.+)',
'tech_email': 'Tech Email: (.+)',
'updated_date': 'Updated Date: *(.+)',
'creation_date': 'Creation Date: *(.+)',
'expiration_date': 'Registry Expiry Date: *(.+)',
'name_servers': 'Name Server: *(.+)'
}
def __init__(self, domain, text):
if 'not found.' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisIt(WhoisEntry):
"""Whois parser for .it domains
"""
regex = {
'domain_name': 'Domain: *(.+)',
'creation_date': '(?<! )Created: *(.+)',
'updated_date': '(?<! )Last Update: *(.+)',
'expiration_date': '(?<! )Expire Date: *(.+)',
'status': 'Status: *(.+)', # list of statuses
'name_servers': 'Nameservers[\s]((?:.+\n)*)', # servers in one string sep by \n
'registrant_organization': '(?<=Registrant)[\s\S]*?Organization:(.*)',
'registrant_address': '(?<=Registrant)[\s\S]*?Address:(.*)',
'admin_address': '(?<=Admin Contact)[\s\S]*?Address:(.*)',
'admin_organization': '(?<=Admin Contact)[\s\S]*?Organization:(.*)',
'admin_name': '(?<=Admin Contact)[\s\S]*?Name:(.*)',
'tech_address': '(?<=Technical Contacts)[\s\S]*?Address:(.*)',
'tech_organization': '(?<=Technical Contacts)[\s\S]*?Organization:(.*)',
'tech_name': '(?<=Technical Contacts)[\s\S]*?Name:(.*)',
'registrar_address': '(?<=Registrar)[\s\S]*?Address:(.*)',
'registrar': '(?<=Registrar)[\s\S]*?Organization:(.*)',
'registrar_name': '(?<=Registrar)[\s\S]*?Name:(.*)',
}
def __init__(self, domain, text):
if 'not found.' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisSa(WhoisEntry):
"""Whois parser for .sa domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'creation_date': 'Created on: *(.+)',
'updated_date': 'Last Updated on: *(.+)',
'name_servers': 'Name Servers:[\s]((?:.+\n)*)', # servers in one string sep by \n
'registrant_name': 'Registrant:\s*(.+)',
'registrant_address': '(?<=Registrant)[\s\S]*?Address:((?:.+\n)*)',
'admin_address': '(?<=Administrative Contact)[\s\S]*?Address:((?:.+\n)*)',
'admin': 'Administrative Contact:\s*(.*)',
'tech_address': '(?<=Technical Contact)[\s\S]*?Address:((?:.+\n)*)',
'tech': 'Technical Contact:\s*(.*)',
}
def __init__(self, domain, text):
if 'not found.' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisSK(WhoisEntry):
"""Whois parser for .sk domains
"""
regex = {
'domain_name': 'Domain: *(.+)',
'creation_date': '(?<=Domain:)[\s\w\W]*?Created: *(.+)',
'updated_date': '(?<=Domain:)[\s\w\W]*?Updated: *(.+)',
'expiration_date': 'Valid Until: *(.+)',
'name_servers': 'Nameserver: *(.+)',
'registrant_name': 'Name:\s*(.+)',
'registrant_email': 'Email:\s*(.+)',
'registrant_phone': 'Phone:\s*(.+)',
'registrant_address': 'Street:\s*(.+)',
'registrar': '(?<=Registrar)[\s\S]*?Organization:(.*)',
'registrar_organization_id': '(?<=Registrar)[\s\S]*?Organization ID:(.*)',
'registrar_name': '(?<=Registrant)[\s\S]*?Name:(.*)',
'registrar_phone': '(?<=Registrant)[\s\S]*?Phone:(.*)',
'registrar_email': '(?<=Registrant)[\s\S]*?Email:(.*)',
'registrar_street': '(?<=Registrant)[\s\S]*?Street:(.*)',
'registrar_city': '(?<=Registrant)[\s\S]*?City:(.*)',
'registrar_postal_code': '(?<=Registrant)[\s\S]*?Postal Code:(.*)',
'registrar_country_code': '(?<=Registrant)[\s\S]*?Country Code:(.*)',
'admin': 'Admin Contact:\s*(.*)',
'admin_organization': '(?<=^Contact)[\s\S]*?Organization:(.*)',
'admin_phone': '(?<=^Contact)[\s\S]*?Phone:(.*)',
'admin_email': '(?<=^Contact)[\s\S]*?Email:(.*)',
'admin_street': '(?<=^Contact)[\s\S]*?Street:(.*)',
'admin_city': '(?<=^Contact)[\s\S]*?City:(.*)',
'admin_postal_code': '(?<=^Contact)[\s\S]*?Postal Code:(.*)',
'admin_country_code': '(?<=^Contact)[\s\S]*?Country Code:(.*)',
'tech': 'Tech Contact:\s*(.*)',
}
def __init__(self, domain, text):
if 'not found.' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisMx(WhoisEntry):
"""Whois parser for .mx domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'creation_date': 'Created On: *(.+)',
'updated_date': 'Last Updated On: *(.+)',
'expiration_date': 'Expiration Date: *(.+)',
'url': 'URL: *(.+)',
'name_servers': 'DNS: (.*)', # servers in one string sep by \n
'registrar': 'Registrar:\s*(.+)',
'registrant_name': '(?<=Registrant)[\s\S]*?Name:(.*)',
'registrant_city': '(?<=Registrant)[\s\S]*?City:(.*)',
'registrant_state': '(?<=Registrant)[\s\S]*?State:(.*)',
'registrant_country': '(?<=Registrant)[\s\S]*?Country:(.*)',
'admin': '(?<=Administrative Contact)[\s\S]*?Name:(.*)',
'admin_city': '(?<=Administrative Contact)[\s\S]*?City:(.*)',
'admin_country': '(?<=Administrative Contact)[\s\S]*?Country:(.*)',
'admin_state': '(?<=Administrative Contact)[\s\S]*?State:(.*)',
'tech_name': '(?<=Technical Contact)[\s\S]*?Name:(.*)',
'tech_city': '(?<=Technical Contact)[\s\S]*?City:(.*)',
'tech_state': '(?<=Technical Contact)[\s\S]*?State:(.*)',
'tech_country': '(?<=Technical Contact)[\s\S]*?Country:(.*)',
'billing_name': '(?<=Billing Contact)[\s\S]*?Name:(.*)',
'billing_city': '(?<=Billing Contact)[\s\S]*?City:(.*)',
'billing_state': '(?<=Billing Contact)[\s\S]*?State:(.*)',
'billing_country': '(?<=Billing Contact)[\s\S]*?Country:(.*)',
}
def __init__(self, domain, text):
if 'not found.' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisTw(WhoisEntry):
"""Whois parser for .tw domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'creation_date': 'Record created on (.+) ',
'expiration_date': 'Record expires on (.+) ',
'name_servers': 'Domain servers in listed order:((?:\s.+)*)', # servers in one string sep by \n
'registrar': 'Registration Service Provider: *(.+)',
'registrar_url': 'Registration Service URL: *(.+)',
'registrant_name': '(?<=Registrant:)\s+(.*)',
'registrant_organization': '(?<=Registrant:)\s*(.*)',
'registrant_city': '(?<=Registrant:)\s*(?:.*\n){5}\s+(.*),',
'registrant_street': '(?<=Registrant:)\s*(?:.*\n){4}\s+(.*)',
'registrant_state_province': '(?<=Registrant:)\s*(?:.*\n){5}.*, (.*)',
'registrant_country': '(?<=Registrant:)\s*(?:.*\n){6}\s+(.*)',
'registrant_phone': '(?<=Registrant:)\s*(?:.*\n){2}\s+(\+*\d.*)',
'registrant_fax': '(?<=Registrant:)\s*(?:.*\n){3}\s+(\+*\d.*)',
'registrant_email': '(?<=Registrant:)\s*(?:.*\n){1}.* (.*)',
'admin': '(?<=Administrative Contact:\n)\s+(.*) ',
'admin_email': '(?<=Administrative Contact:)\s*.* (.*)',
'admin_phone': '(?<=Administrative Contact:\n)\s*(?:.*\n){1}\s+(\+*\d.*)',
'admin_fax': '(?<=Administrative Contact:\n)\s*(?:.*\n){2}\s+(\+*\d.*)',
'tech': '(?<=Technical Contact:\n)\s+(.*) ',
'tech_email': '(?<=Technical Contact:)\s*.* (.*)',
'tech_phone': '(?<=Technical Contact:\n)\s*(?:.*\n){1}\s+(\+*\d.*)',
'tech_fax': '(?<=Technical Contact:\n)\s*(?:.*\n){2}\s+(\+*\d.*)',
}
def __init__(self, domain, text):
if 'not found.' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisTr(WhoisEntry):
"""Whois parser for .tr domains
"""
regex = {
'domain_name': '[**] Domain Name: *(.+)',
'creation_date': 'Created on.*: *(.+)',
'expiration_date': 'Expires on.*: *(.+)',
'name_servers': '[**] Domain servers:((?:\s.+)*)', # servers in one string sep by \n
'registrant_name': '(?<=[**] Registrant:)[\s\S]((?:\s.+)*)',
'admin': '(?<=[**] Administrative Contact:)[\s\S]*?NIC Handle\s+: (.*)',
'admin_organization': '(?<=[**] Administrative Contact:)[\s\S]*?Organization Name\s+: (.*)',
'admin_address': '(?<=[**] Administrative Contact)[\s\S]*?Address\s+: (.*)',
'admin_phone': '(?<=[**] Administrative Contact)[\s\S]*?Phone\s+: (.*)',
'admin_fax': '(?<=[**] Administrative Contact)[\s\S]*?Fax\s+: (.*)',
'tech': '(?<=[**] Technical Contact:)[\s\S]*?NIC Handle\s+: (.*)',
'tech_organization': '(?<=[**] Technical Contact:)[\s\S]*?Organization Name\s+: (.*)',
'tech_address': '(?<=[**] Technical Contact)[\s\S]*?Address\s+: (.*)',
'tech_phone': '(?<=[**] Technical Contact)[\s\S]*?Phone\s+: (.*)',
'tech_fax': '(?<=[**] Technical Contact)[\s\S]*?Fax\s+: (.*)',
'billing': '(?<=[**] Billing Contact:)[\s\S]*?NIC Handle\s+: (.*)',
'billing_organization': '(?<=[**] Billing Contact:)[\s\S]*?Organization Name\s+: (.*)',
'billing_address': '(?<=[**] Billing Contact)[\s\S]*?Address\s+: (.*)',
'billing_phone': '(?<=[**] Billing Contact)[\s\S]*?Phone\s+: (.*)',
'billing_fax': '(?<=[**] Billing Contact)[\s\S]*?Fax\s+: (.*)',
}
def __init__(self, domain, text):
if 'not found.' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisIs(WhoisEntry):
"""Whois parser for .se domains
"""
regex = {
'domain_name': 'domain\.*: *(.+)',
'registrant_name': 'registrant: *(.+)',
'name': 'person\.*: *(.+)',
'address': 'address\.*: *(.+)',
'creation_date': 'created\.*: *(.+)',
'expiration_date': 'expires\.*: *(.+)',
'email': 'e-mail: *(.+)',
'name_servers': 'nserver\.*: *(.+)', # list of name servers
'dnssec': 'dnssec\.*: *(.+)',
}
def __init__(self, domain, text):
if 'No entries found' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisDk(WhoisEntry):
"""Whois parser for .dk domains
"""
regex = {
'domain_name': 'Domain: *(.+)',
'creation_date': 'Registered: *(.+)',
'expiration_date': 'Expires: *(.+)',
'dnssec': 'Dnssec: *(.+)',
'status': 'Status: *(.+)',
'registrant_handle': 'Registrant\s*(?:.*\n){1}\s*Handle: *(.+)',
'registrant_name': 'Registrant\s*(?:.*\n){2}\s*Name: *(.+)',
'registrant_address': 'Registrant\s*(?:.*\n){3}\s*Address: *(.+)',
'registrant_zip_code': 'Registrant\s*(?:.*\n){4}\s*Postalcode: *(.+)',
'registrant_city': 'Registrant\s*(?:.*\n){5}\s*City: *(.+)',
'registrant_country': 'Registrant\s*(?:.*\n){6}\s*Country: *(.+)',
'name_servers': 'Nameservers\n *([\n\S\s]+)'
}
def __init__(self, domain, text):
if 'No match for ' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
def _preprocess(self, attr, value):
if attr == 'name_servers':
return [
line.split(":")[-1].strip()
for line in value.split("\n")
if line.startswith("Hostname")
]
return super(WhoisDk, self)._preprocess(attr, value)
class WhoisAi(WhoisEntry):
"""Whois parser for .ai domains
"""
regex = {
'domain_name': 'Complete Domain Name\.*: *(.+)',
'name': 'Name \(Last, First\)\.*: *(.+)',
'org': 'Organization Name\.*: *(.+)',
'address': 'Street Address\.*: *(.+)',
'city': 'City\.*: *(.+)',
'state': 'State\.*: *(.+)',
'zipcode': 'Postal Code\.*: *(\d+)',
'country': 'Country\.*: *(.+)',
'name_servers': 'Server Hostname\.*: *(.+)',
}
def __init__(self, domain, text):
if 'not registered' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisIl(WhoisEntry):
"""Whois parser for .il domains
"""
regex = {
'domain_name': 'domain: *(.+)',
'expiration_date': 'validity: *(.+)',
'registrant_name': 'person: *(.+)',
'registrant_address': 'address *(.+)',
'dnssec': 'DNSSEC: *(.+)',
'status': 'status: *(.+)',
'name_servers': 'nserver: *(.+)',
'emails': 'e-mail: *(.+)',
'phone': 'phone: *(.+)',
'registrar': 'registrar name: *(.+)',
'referral_url': 'registrar info: *(.+)',
}
dayfirst = True
def __init__(self, domain, text):
if 'No data was found' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
def _preprocess(self, attr, value):
if attr == 'emails':
value = value.replace(' AT ', '@')
return super(WhoisIl, self)._preprocess(attr, value)
class WhoisIn(WhoisEntry):
"""Whois parser for .in domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'registrar': 'Registrar: *(.+)',
'registrar_url': 'Registrar URL: *(.+)',
'registrar_iana': 'Registrar IANA ID: *(\d+)',
'updated_date': 'Updated Date: *(.+)|Last Updated On: *(.+)',
'creation_date': 'Creation Date: *(.+)|Created On: *(.+)',
'expiration_date': 'Expiration Date: *(.+)|Registry Expiry Date: *(.+)',
'name_servers': 'Name Server: *(.+)',
'organization': 'Registrant Organization: *(.+)',
'state': 'Registrant State/Province: *(.+)',
'status': 'Status: *(.+)',
'emails': EMAIL_REGEX,
'country': 'Registrant Country: *(.+)',
'dnssec': 'DNSSEC: *([\S]+)',
}
def __init__(self, domain, text):
if 'NOT FOUND' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisCat(WhoisEntry):
"""Whois parser for .cat domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'registrar': 'Registrar: *(.+)',
'updated_date': 'Updated Date: *(.+)',
'creation_date': 'Creation Date: *(.+)',
'expiration_date': 'Registry Expiry Date: *(.+)',
'name_servers': 'Name Server: *(.+)',
'status': 'Domain status: *(.+)',
'emails': EMAIL_REGEX,
}
def __init__(self, domain, text):
if 'no matching objects' in text:
raise PywhoisError(text)
else:
# Merge base class regex with specifics
self._regex.copy().update(self.regex)
self.regex = self._regex
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisIe(WhoisEntry):
"""Whois parser for .ie domains
"""
regex = {
'domain_name': 'Domain: *(.+)',
'registrant_name': 'Domain Holder: *(.+)',
'description': 'descr: *(.+)',
'source': 'Source: *(.+)',
'creation_date': 'Registration Date: *(.+)',
'expiration_date': 'Renewal Date: *(.+)',
'name_servers': 'Nserver: *(.+)',
'status': 'Renewal status: *(.+)',
'admin_id': 'Admin-c: *(.+)',
'tech_id': 'Tech-c: *(.+)',
'registrar': 'Account Name: *(.+)',
'registrar_contact':'Registrar Abuse Contact: *(.+)'
}
def __init__(self, domain, text):
if 'no matching objects' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisNz(WhoisEntry):
"""Whois parser for .nz domains
"""
regex = {
'domain_name': 'domain_name:\s*([^\n\r]+)',
'registrar': 'registrar_name:\s*([^\n\r]+)',
'updated_date': 'domain_datelastmodified:\s*([^\n\r]+)',
'creation_date': 'domain_dateregistered:\s*([^\n\r]+)',
'expiration_date': 'domain_datebilleduntil:\s*([^\n\r]+)',
'name_servers': 'ns_name_\d*:\s*([^\n\r]+)', # list of name servers
'status': 'status:\s*([^\n\r]+)', # list of statuses
'emails': EMAIL_REGEX, # list of email s
'name': 'registrant_contact_name:\s*([^\n\r]+)',
'address': 'registrant_contact_address\d*:\s*([^\n\r]+)',
'city': 'registrant_contact_city:\s*([^\n\r]+)',
'zipcode': 'registrant_contact_postalcode:\s*([^\n\r]+)',
'country': 'registrant_contact_country:\s*([^\n\r]+)',
}
def __init__(self, domain, text):
if 'no matching objects' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisLu(WhoisEntry):
"""Whois parser for .lu domains
"""
regex = {
'domain_name': 'domainname: *(.+)',
'creation_date': 'registered: *(.+)',
'name_servers': 'nserver: *(.+)',
'status': 'domaintype: *(.+)',
'registrar': 'registrar-name: *(.+)',
'registrant_name': 'org-name: *(.+)',
'registrant_address': 'org-address: *(.+)',
'registrant_postal_code': 'org-zipcode:*(.+)',
'registrant_city': 'org-city: *(.+)',
'registrant_country': 'org-country: *(.+)',
'admin_name': 'adm-name: *(.+)',
'admin_address': 'adm-address: *(.+)',
'admin_postal_code': 'adm-zipcode: *(.+)',
'admin_city': 'adm-city: *(.+)',
'admin_country': 'adm-country: *(.+)',
'admin_email': 'adm-email: *(.+)',
'tech_name': 'tec-name: *(.+)',
'tech_address': 'tec-address: *(.+)',
'tech_postal_code': 'tec-zipcode: *(.+)',
'tech_city': 'tec-city: *(.+)',
'tech_country': 'tec-country: *(.+)',
'tech_email': 'tec-email: *(.+)',
}
def __init__(self, domain, text):
if 'No such domain' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisCz(WhoisEntry):
"""Whois parser for .cz domains
"""
regex = {
'domain_name': 'domain: *(.+)',
'registrant_name': 'registrant: *(.+)',
'registrar': 'registrar: *(.+)',
'creation_date': 'registered: *(.+)',
'updated_date': 'changed: *(.+)',
'expiration_date': 'expire: *(.+)',
'name_servers': 'nserver: *(.+)',
}
def __init__(self, domain, text):
if '% No entries found.' in text or 'Your connection limit exceeded' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisOnline(WhoisEntry):
"""Whois parser for .online domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'domain__id': 'Domain ID: *(.+)',
'whois_server': 'Registrar WHOIS Server: *(.+)',
'registrar': 'Registrar: *(.+)',
'registrar_id': 'Registrar IANA ID: *(.+)',
'registrar_url': 'Registrar URL: *(.+)',
'status': 'Domain Status: *(.+)',
'registrant_email': 'Registrant Email: *(.+)',
'admin_email': 'Admin Email: *(.+)',
'billing_email': 'Billing Email: *(.+)',
'tech_email': 'Tech Email: *(.+)',
'name_servers': 'Name Server: *(.+)',
'creation_date': 'Creation Date: *(.+)',
'expiration_date': 'Registry Expiry Date: *(.+)',
'updated_date': 'Updated Date: *(.+)',
'dnssec': 'DNSSEC: *([\S]+)',
}
def __init__(self, domain, text):
if 'Not found:' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisHr(WhoisEntry):
"""Whois parser for .hr domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'whois_server': 'Registrar WHOIS Server: *(.+)',
'registrar_url': 'Registrar URL: *(.+)',
'updated_date': 'Updated Date: *(.+)',
'creation_date': 'Creation Date: *(.+)',
'expiration_date': 'Registrar Registration Expiration Date: *(.+)',
'name_servers': 'Name Server: *(.+)',
'registrant_name': 'Registrant Name:\s(.+)',
'registrant_address': 'Reigstrant Street:\s*(.+)',
}
def __init__(self, domain, text):
if 'ERROR: No entries found' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisHk(WhoisEntry):
"""Whois parser for .hk domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'status': 'Domain Status: *(.+)',
'dnssec': 'DNSSEC: *(.+)',
'whois_server': 'Registrar WHOIS Server: *(.+)',
'registrar_url': 'Registrar URL: *(.+)',
'registrar': 'Registrar Name: *(.+)',
'registrar_email': 'Registrar Contact Information: Email: *(.+)',
'registrant_company_name': 'Registrant Contact Information:\s*Company English Name.*:(.+)',
'registrant_address': '(?<=Registrant Contact Information:)[\s\S]*?Address: (.*)',
'registrant_country': '[Registrant Contact Information\w\W]+Country: ([\S\ ]+)',
'registrant_email': '[Registrant Contact Information\w\W]+Email: ([\S\ ]+)',
'admin_name': '[Administrative Contact Information\w\W]+Given name: ([\S\ ]+)',
'admin_family_name': '[Administrative Contact Information\w\W]+Family name: ([\S\ ]+)',
'admin_company_name': '[Administrative Contact Information\w\W]+Company name: ([\S\ ]+)',
'admin_address': '(?<=Administrative Contact Information:)[\s\S]*?Address: (.*)',
'admin_country': '[Administrative Contact Information\w\W]+Country: ([\S\ ]+)',
'admin_phone': '[Administrative Contact Information\w\W]+Phone: ([\S\ ]+)',
'admin_fax': '[Administrative Contact Information\w\W]+Fax: ([\S\ ]+)',
'admin_email': '[Administrative Contact Information\w\W]+Email: ([\S\ ]+)',
'admin_account_name': '[Administrative Contact Information\w\W]+Account Name: ([\S\ ]+)',
'tech_name': '[Technical Contact Information\w\W]+Given name: (.+)',
'tech_family_name': '[Technical Contact Information\w\W]+Family name: (.+)',
'tech_company_name': '[Technical Contact Information\w\W]+Company name: (.+)',
'tech_address': '(?<=Technical Contact Information:)[\s\S]*?Address: (.*)',
'tech_country': '[Technical Contact Information\w\W]+Country: (.+)',
'tech_phone': '[Technical Contact Information\w\W]+Phone: (.+)',
'tech_fax': '[Technical Contact Information\w\W]+Fax: (.+)',
'tech_email': '[Technical Contact Information\w\W]+Email: (.+)',
'tech_account_name': '[Technical Contact Information\w\W]+Account Name: (.+)',
'updated_date': 'Updated Date: *(.+)',
'creation_date': '[Registrant Contact Information\w\W]+Domain Name Commencement Date: (.+)',
'expiration_date': '[Registrant Contact Information\w\W]+Expiry Date: (.+)',
'name_servers': 'Name Servers Information:\s+((?:.+\n)*)'
}
def __init__(self, domain, text):
if 'ERROR: No entries found' in text or 'The domain has not been registered' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisUA(WhoisEntry):
"""Whois parser for .ua domains
"""
regex = {
'domain_name': 'domain: *(.+)',
'status': 'status: *(.+)',
'registrar': '(?<=Registrar:)[\s\W\w]*?organization-loc:(.*)',
'registrar_name': '(?<=Registrar:)[\s\W\w]*?registrar:(.*)',
'registrar_url': '(?<=Registrar:)[\s\W\w]*?url:(.*)',
'registrar_country': '(?<=Registrar:)[\s\W\w]*?country:(.*)',
'registrar_city': '(?<=Registrar:)[\s\W\w]*?city:\s+(.*)\n',
'registrar_address': '(?<=Registrar:)[\s\W\w]*?abuse-postal:\s+(.*)\n',
'registrar_email': '(?<=Registrar:)[\s\W\w]*?abuse-email:(.*)',
'registrant_name': '(?<=Registrant:)[\s\W\w]*?organization-loc:(.*)',
'registrant_country': '(?<=Registrant:)[\s\W\w]*?country-loc:(.*)',
'registrant_city': '(?<=Registrant:)[\s\W\w]*?(?:address\-loc:\s+.*\n){2}address-loc:\s+(.*)\n',
'registrant_state': '(?<=Registrant:)[\s\W\w]*?(?:address\-loc:\s+.*\n){1}address-loc:\s+(.*)\n',
'registrant_address': '(?<=Registrant:)[\s\W\w]*?address-loc:\s+(.*)\n',
'registrant_email': '(?<=Registrant:)[\s\W\w]*?e-mail:(.*)',
'registrant_postal_code': '(?<=Registrant:)[\s\W\w]*?postal-code-loc:(.*)',
'registrant_phone': '(?<=Registrant:)[\s\W\w]*?phone:(.*)',
'registrant_fax': '(?<=Registrant:)[\s\W\w]*?fax:(.*)',
'admin': '(?<=Administrative Contacts:)[\s\W\w]*?organization-loc:(.*)',
'admin_country': '(?<=Administrative Contacts:)[\s\W\w]*?country-loc:(.*)',
'admin_city': '(?<=Administrative Contacts:)[\s\W\w]*?(?:address\-loc:\s+.*\n){2}address-loc:\s+(.*)\n',
'admin_state': '(?<=Administrative Contacts:)[\s\W\w]*?(?:address\-loc:\s+.*\n){1}address-loc:\s+(.*)\n',
'admin_address': '(?<=Administrative Contacts:)[\s\W\w]*?address-loc:\s+(.*)\n',
'admin_email': '(?<=Administrative Contacts:)[\s\W\w]*?e-mail:(.*)',
'admin_postal_code': '(?<=Administrative Contacts:)[\s\W\w]*?postal-code-loc:(.*)',
'admin_phone': '(?<=Administrative Contacts:)[\s\W\w]*?phone:(.*)',
'admin_fax': '(?<=Administrative Contacts:)[\s\W\w]*?fax:(.*)',
'updated_date': 'modified: *(.+)',
'creation_date': 'created: (.+)',
'expiration_date': 'expires: (.+)',
'name_servers': 'nserver: *(.+)'
}
def __init__(self, domain, text):
if 'ERROR: No entries found' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisHn(WhoisEntry):
"""Whois parser for .hn domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'domain_id': 'Domain ID: *(.+)',
'status': 'Domain Status: *(.+)',
'whois_server': 'WHOIS Server: *(.+)',
'registrar_url': 'Registrar URL: *(.+)',
'registrar': 'Registrar: *(.+)',
'registrant_name': 'Registrant Name: (.+)',
'registrant_id': 'Registrant ID: (.+)',
'registrant_organization': 'Registrant Organization: (.+)',
'registrant_city': 'Registrant City: (.*)',
'registrant_street': 'Registrant Street: (.*)',
'registrant_state_province': 'Registrant State/Province: (.*)',
'registrant_postal_code': 'Registrant Postal Code: (.*)',
'registrant_country': 'Registrant Country: (.+)',
'registrant_phone': 'Registrant Phone: (.+)',
'registrant_fax': 'Registrant Fax: (.+)',
'registrant_email': 'Registrant Email: (.+)',
'admin_name': 'Admin Name: (.+)',
'admin_id': 'Admin ID: (.+)',
'admin_organization': 'Admin Organization: (.+)',
'admin_city': 'Admin City: (.*)',
'admin_street': 'Admin Street: (.*)',
'admin_state_province': 'Admin State/Province: (.*)',
'admin_postal_code': 'Admin Postal Code: (.*)',
'admin_country': 'Admin Country: (.+)',
'admin_phone': 'Admin Phone: (.+)',
'admin_fax': 'Admin Fax: (.+)',
'admin_email': 'Admin Email: (.+)',
'billing_name': 'Billing Name: (.+)',
'billing_id': 'Billing ID: (.+)',
'billing_organization': 'Billing Organization: (.+)',
'billing_city': 'Billing City: (.*)',
'billing_street': 'Billing Street: (.*)',
'billing_state_province': 'Billing State/Province: (.*)',
'billing_postal_code': 'Billing Postal Code: (.*)',
'billing_country': 'Billing Country: (.+)',
'billing_phone': 'Billing Phone: (.+)',
'billing_fax': 'Billing Fax: (.+)',
'billing_email': 'Billing Email: (.+)',
'tech_name': 'Tech Name: (.+)',
'tech_id': 'Tech ID: (.+)',
'tech_organization': 'Tech Organization: (.+)',
'tech_city': 'Tech City: (.*)',
'tech_street': 'Tech Street: (.*)',
'tech_state_province': 'Tech State/Province: (.*)',
'tech_postal_code': 'Tech Postal Code: (.*)',
'tech_country': 'Tech Country: (.+)',
'tech_phone': 'Tech Phone: (.+)',
'tech_fax': 'Tech Fax: (.+)',
'tech_email': 'Tech Email: (.+)',
'updated_date': 'Updated Date: *(.+)',
'creation_date': 'Creation Date: *(.+)',
'expiration_date': 'Registry Expiry Date: *(.+)',
'name_servers': 'Name Server: *(.+)'
}
def __init__(self, domain, text):
if text.strip() == 'No matching record.':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisLat(WhoisEntry):
"""Whois parser for .lat domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'domain_id': 'Registry Domain ID: *(.+)',
'status': 'Domain Status: *(.+)',
'whois_server': 'Registrar WHOIS Server: *(.+)',
'registrar_url': 'Registrar URL: *(.+)',
'registrar': 'Registrar: *(.+)',
'registrar_email': 'Registrar Abuse Contact Email: *(.+)',
'registrar_phone': 'Registrar Abuse Contact Phone: *(.+)',
'registrant_name': 'Registrant Name: (.+)',
'registrant_id': 'Registry Registrant ID: (.+)',
'registrant_organization': 'Registrant Organization: (.+)',
'registrant_city': 'Registrant City: (.*)',
'registrant_street': 'Registrant Street: (.*)',
'registrant_state_province': 'Registrant State/Province: (.*)',
'registrant_postal_code': 'Registrant Postal Code: (.*)',
'registrant_country': 'Registrant Country: (.+)',
'registrant_phone': 'Registrant Phone: (.+)',
'registrant_fax': 'Registrant Fax: (.+)',
'registrant_email': 'Registrant Email: (.+)',
'admin_name': 'Admin Name: (.+)',
'admin_id': 'Registry Admin ID: (.+)',
'admin_organization': 'Admin Organization: (.+)',
'admin_city': 'Admin City: (.*)',
'admin_street': 'Admin Street: (.*)',
'admin_state_province': 'Admin State/Province: (.*)',
'admin_postal_code': 'Admin Postal Code: (.*)',
'admin_country': 'Admin Country: (.+)',
'admin_phone': 'Admin Phone: (.+)',
'admin_fax': 'Admin Fax: (.+)',
'admin_email': 'Admin Email: (.+)',
'tech_name': 'Tech Name: (.+)',
'tech_id': 'Registry Tech ID: (.+)',
'tech_organization': 'Tech Organization: (.+)',
'tech_city': 'Tech City: (.*)',
'tech_street': 'Tech Street: (.*)',
'tech_state_province': 'Tech State/Province: (.*)',
'tech_postal_code': 'Tech Postal Code: (.*)',
'tech_country': 'Tech Country: (.+)',
'tech_phone': 'Tech Phone: (.+)',
'tech_fax': 'Tech Fax: (.+)',
'tech_email': 'Tech Email: (.+)',
'updated_date': 'Updated Date: *(.+)',
'creation_date': 'Creation Date: *(.+)',
'expiration_date': 'Registry Expiry Date: *(.+)',
'name_servers': 'Name Server: *(.+)'
}
def __init__(self, domain, text):
if text.strip() == 'No matching record.':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisCn(WhoisEntry):
"""Whois parser for .cn domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'registrar': 'Registrar: *(.+)',
'creation_date': 'Registration Time: *(.+)',
'expiration_date': 'Expiration Time: *(.+)',
'name_servers': 'Name Server: *(.+)', # list of name servers
'status': 'Status: *(.+)', # list of statuses
'emails': EMAIL_REGEX, # list of email s
'dnssec': 'dnssec: *([\S]+)',
'name': 'Registrant: *(.+)',
}
def __init__(self, domain, text):
if text.strip() == 'No matching record.':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisApp(WhoisEntry):
"""Whois parser for .app domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'registrar': 'Registrar: *(.+)',
'whois_server': 'Whois Server: *(.+)',
'updated_date': 'Updated Date: *(.+)',
'creation_date': 'Creation Date: *(.+)',
'expiration_date': 'Expir\w+ Date: *(.+)',
'name_servers': 'Name Server: *(.+)', # list of name servers
'status': 'Status: *(.+)', # list of statuses
'emails': EMAIL_REGEX, # list of email s
'registrant_email': 'Registrant Email: *(.+)', # registrant email
'registrant_phone': 'Registrant Phone: *(.+)', # registrant phone
'dnssec': 'dnssec: *([\S]+)',
'name': 'Registrant Name: *(.+)',
'org': 'Registrant\s*Organization: *(.+)',
'address': 'Registrant Street: *(.+)',
'city': 'Registrant City: *(.+)',
'state': 'Registrant State/Province: *(.+)',
'zipcode': 'Registrant Postal Code: *(.+)',
'country': 'Registrant Country: *(.+)',
}
def __init__(self, domain, text):
if text.strip() == 'Domain not found.':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisMoney(WhoisEntry):
"""Whois parser for .money domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'registrar': 'Registrar: *(.+)',
'whois_server': 'Registrar WHOIS Server: *(.+)',
'updated_date': 'Updated Date: *(.+)',
'creation_date': 'Creation Date: *(.+)',
'expiration_date': 'Registry Expiry Date: *(.+)',
'name_servers': 'Name Server: *(.+)', # list of name servers
'status': 'Domain Status: *(.+)',
'emails': EMAIL_REGEX, # list of emails
'registrant_email': 'Registrant Email: *(.+)',
'registrant_phone': 'Registrant Phone: *(.+)',
'dnssec': 'DNSSEC: *(.+)',
'name': 'Registrant Name: *(.+)',
'org': 'Registrant Organization: *(.+)',
'address': 'Registrant Street: *(.+)',
'city': 'Registrant City: *(.+)',
'state': 'Registrant State/Province: *(.+)',
'zipcode': 'Registrant Postal Code: *(.+)',
'country': 'Registrant Country: *(.+)',
}
def __init__(self, domain, text):
if text.strip() == 'Domain not found.':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisAr(WhoisEntry):
"""Whois parser for .ar domains
"""
regex = {
'domain_name': 'domain: *(.+)',
'registrar': 'registrar: *(.+)',
'whois_server': 'whois: *(.+)',
'updated_date': 'changed: *(.+)',
'creation_date': 'created: *(.+)',
'expiration_date': 'expire: *(.+)',
'name_servers': 'nserver: *(.+) \(.*\)', # list of name servers
'status': 'Domain Status: *(.+)',
'emails': EMAIL_REGEX, # list of emails
'name': 'name: *(.+)',
}
def __init__(self, domain, text):
if text.strip() == 'El dominio no se encuentra registrado en NIC Argentina':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisBy(WhoisEntry):
"""Whois parser for .by domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'registrar': 'Registrar: *(.+)',
'updated_date': 'Updated Date: *(.+)',
'creation_date': 'Creation Date: *(.+)',
'expiration_date': 'Expiration Date: *(.+)',
'name_servers': 'Name Server: *(.+)', # list of name servers
'status': 'Domain Status: *(.+)',
'name': 'Person: *(.+)',
'org': 'Org: *(.+)',
'registrant_country': 'Country: *(.+)',
'registrant_address': 'Address: *(.+)',
'registrant_phone': 'Phone: *(.+)',
}
def __init__(self, domain, text):
if text.strip() == 'El dominio no se encuentra registrado en NIC Argentina':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisCr(WhoisEntry):
"""Whois parser for .cr domains
"""
regex = {
'domain_name': 'domain: *(.+)',
'registrant_name': 'registrant: *(.+)',
'registrar': 'registrar: *(.+)',
'updated_date': 'changed: *(.+)',
'creation_date': 'registered: *(.+)',
'expiration_date': 'expire: *(.+)',
'name_servers': 'nserver: *(.+)', # list of name servers
'status': 'status: *(.+)',
'contact': 'contact: *(.+)',
'name': 'name: *(.+)',
'org': 'org: *(.+)',
'address': 'address: *(.+)',
'phone': 'phone: *(.+)',
}
def __init__(self, domain, text):
if text.strip() == 'El dominio no existe.':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisVe(WhoisEntry):
"""Whois parser for .ve domains
"""
regex = {
'domain_name': 'Nombre de Dominio: *(.+)',
'status': 'Estatus del dominio: *(.+)',
'registrar': 'registrar: *(.+)',
'updated_date': 'Ultima Actualización: *(.+)',
'creation_date': 'Fecha de Creación: *(.+)',
'expiration_date': 'Fecha de Vencimiento: *(.+)',
'name_servers': 'Nombres de Dominio:((?:\s+- .*)*)',
'registrant_name': 'Titular:\s*(?:.*\n){1}\s+(.*)',
'registrant_city': 'Titular:\s*(?:.*\n){3}\s+([\s\w]*)',
'registrant_street': 'Titular:\s*(?:.*\n){2}\s+(.*)',
'registrant_state_province': 'Titular:\s*(?:.*\n){3}\s+.*?,(.*),',
'registrant_country': 'Titular:\s*(?:.*\n){3}\s+.*, .+ (.*)',
'registrant_phone': 'Titular:\s*(?:.*\n){4}\s+(\+*\d.+)',
'registrant_email': 'Titular:\s*.*\t(.*)',
'tech': 'Contacto Técnico:\s*(?:.*\n){1}\s+(.*)',
'tech_city': 'Contacto Técnico:\s*(?:.*\n){3}\s+([\s\w]*)',
'tech_street': 'Contacto Técnico:\s*(?:.*\n){2}\s+(.*)',
'tech_state_province': 'Contacto Técnico:\s*(?:.*\n){3}\s+.*?,(.*),',
'tech_country': 'Contacto Técnico:\s*(?:.*\n){3}\s+.*, .+ (.*)',
'tech_phone': 'Contacto Técnico:\s*(?:.*\n){4}\s+(\+*\d.*)\(',
'tech_fax': 'Contacto Técnico:\s*(?:.*\n){4}\s+.*\(FAX\) (.*)',
'tech_email': 'Contacto Técnico:\s*.*\t(.*)',
'admin': 'Contacto Administrativo:\s*(?:.*\n){1}\s+(.*)',
'admin_city': 'Contacto Administrativo:\s*(?:.*\n){3}\s+([\s\w]*)',
'admin_street': 'Contacto Administrativo:\s*(?:.*\n){2}\s+(.*)',
'admin_state_province': 'Contacto Administrativo:\s*(?:.*\n){3}\s+.*?,(.*),',
'admin_country': 'Contacto Administrativo:\s*(?:.*\n){3}\s+.*, .+ (.*)',
'admin_phone': 'Contacto Administrativo:\s*(?:.*\n){4}\s+(\+*\d.*)\(',
'admin_fax': 'Contacto Administrativo:\s*(?:.*\n){4}\s+.*\(FAX\) (.*)',
'admin_email': 'Contacto Administrativo:\s*.*\t(.*)',
'billing': 'Contacto de Cobranza:\s*(?:.*\n){1}\s+(.*)',
'billing_city': 'Contacto de Cobranza:\s*(?:.*\n){3}\s+([\s\w]*)',
'billing_street': 'Contacto de Cobranza:\s*(?:.*\n){2}\s+(.*)',
'billing_state_province': 'Contacto de Cobranza:\s*(?:.*\n){3}\s+.*?,(.*),',
'billing_country': 'Contacto de Cobranza:\s*(?:.*\n){3}\s+.*, .+ (.*)',
'billing_phone': 'Contacto de Cobranza:\s*(?:.*\n){4}\s+(\+*\d.*)\(',
'billing_fax': 'Contacto de Cobranza:\s*(?:.*\n){4}\s+.*\(FAX\) (.*)',
'billing_email': 'Contacto de Cobranza:\s*.*\t(.*)',
}
def __init__(self, domain, text):
if text.strip() == 'El dominio no existe.':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisDo(WhoisEntry):
"""Whois parser for .do domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'whois_server': 'WHOIS Server: *(.+)',
'registrar': 'Registrar: *(.+)',
'registrar_email': 'Registrar Customer Service Email: *(.+)',
'registrar_phone': 'Registrar Phone: *(.+)',
'registrar_address': 'Registrar Address: *(.+)',
'registrar_country': 'Registrar Country: *(.+)',
'status': 'Domain Status: *(.+)', # list of statuses
'registrant_id': 'Registrant ID: *(.+)',
'registrant_name': 'Registrant Name: *(.+)',
'registrant_organization': 'Registrant Organization: *(.+)',
'registrant_address': 'Registrant Street: *(.+)',
'registrant_city': 'Registrant City: *(.+)',
'registrant_state_province': 'Registrant State/Province: *(.+)',
'registrant_postal_code': 'Registrant Postal Code: *(.+)',
'registrant_country': 'Registrant Country: *(.+)',
'registrant_phone_number': 'Registrant Phone: *(.+)',
'registrant_email': 'Registrant Email: *(.+)',
'admin_id': 'Admin ID: *(.+)',
'admin_name': 'Admin Name: *(.+)',
'admin_organization': 'Admin Organization: *(.+)',
'admin_address': 'Admin Street: *(.+)',
'admin_city': 'Admin City: *(.+)',
'admin_state_province': 'Admin State/Province: *(.+)',
'admin_postal_code': 'Admin Postal Code: *(.+)',
'admin_country': 'Admin Country: *(.+)',
'admin_phone_number': 'Admin Phone: *(.+)',
'admin_email': 'Admin Email: *(.+)',
'billing_id': 'Billing ID: *(.+)',
'billing_name': 'Billing Name: *(.+)',
'billing_address': 'Billing Street: *(.+)',
'billing_city': 'Billing City: *(.+)',
'billing_state_province': 'Billing State/Province: *(.+)',
'billing_postal_code': 'Billing Postal Code: *(.+)',
'billing_country': 'Billing Country: *(.+)',
'billing_phone_number': 'Billing Phone: *(.+)',
'billing_email': 'Billing Email: *(.+)',
'tech_id': 'Tech ID: *(.+)',
'tech_name': 'Tech Name: *(.+)',
'tech_organization': 'Tech Organization: *(.+)',
'tech_address': 'Tech Street: *(.+)',
'tech_city': 'Tech City: *(.+)',
'tech_state_province': 'Tech State/Province: *(.+)',
'tech_postal_code': 'Tech Postal Code: *(.+)',
'tech_country': 'Tech Country: *(.+)',
'tech_phone_number': 'Tech Phone: *(.+)',
'tech_email': 'Tech Email: *(.+)',
'name_servers': 'Name Server: *(.+)', # list of name servers
'creation_date': 'Creation Date: *(.+)',
'expiration_date': 'Registry Expiry Date: *(.+)',
'updated_date': 'Updated Date: *(.+)',
'dnssec': 'DNSSEC: *(.+)'
}
def __init__(self, domain, text):
if text.strip() == 'Extensión de dominio no válido.':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisAe(WhoisEntry):
"""Whois parser for .ae domains
"""
regex = {
'domain_name': 'Domain Name: *(.+)',
'status': 'Status: *(.+)',
'registrant_name': 'Registrant Contact Name: *(.+)',
'tech_name': 'Tech Contact Name: *(.+)',
}
def __init__(self, domain, text):
if text.strip() == 'No Data Found':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisSi(WhoisEntry):
"""Whois parser for .si domains
"""
regex = {
'domain_name': 'domain: *(.+)',
'registrar': 'registrar: *(.+)',
'name_servers': 'nameserver: *(.+)',
'registrant_name': 'registrant: *(.+)',
'creation_date': 'created: *(.+)',
'expiration_date': 'expire: *(.+)',
}
def __init__(self, domain, text):
if 'No entries found for the selected source(s).' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisNo(WhoisEntry):
"""Whois parser for .no domains
"""
regex = {
'domain_name': 'Domain Name.*:\s*(.+)',
'creation_date': 'Additional information:\nCreated:\s*(.+)',
'updated_date': 'Additional information:\n(?:.*\n)Last updated:\s*(.+)',
}
def __init__(self, domain, text):
if 'No match' in text:
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
class WhoisKZ(WhoisEntry):
"""Whois parser for .kz domains
"""
regex = {
'domain_name': 'Domain Name............: *(.+)',
'registar_created': 'Registar Created: *(.+)',
'curent_registrar': 'Current Registar: *(.+)',
'creation_date': 'Domain created: *(.+)',
'lats_modified': 'Last modified : *(.+)',
'name_servers': 'server.*: *(.+)', # list of name servers
'status': ' (.+?) -', # list of statuses
'emails': EMAIL_REGEX, # list of email addresses
'org': 'Organization Name.*: *(.+)'
}
def __init__(self, domain, text):
if text.strip() == 'No entries found':
raise PywhoisError(text)
else:
WhoisEntry.__init__(self, domain, text, self.regex)
Zerion Mini Shell 1.0