"""Retrieves the most recent geckodriver version."""

global geckodriver_version

response = request.urlopen(GECKODRIVER_INFO_URL)

content = response.read()

match = GECKODRIVER_RELEASES_VERSION_PATTERN.search(str(content))

if match:

return match.group(1)

else:

raise Exception('Unable to get latest geckodriver version from {0}'

"""Downloads and unzips the requested geckodriver executable."""

def _download(self, zip_path):

compression = 'tar.gz'

architecture = platform.architecture()[0][:-3]

plat = platform.platform().lower()

if plat.startswith('darwin'):

os_ = 'macos'

# Only 64 bit architecture is available for mac since version 2.23

architecture = ''

elif plat.startswith('linux'):

os_ = 'linux'

elif plat.startswith('win'):

os_ = 'win'

compression = 'zip'

else:

raise Exception('Unsupported platform: {0}'.format(plat))

url = GECKODRIVER_URL_TEMPLATE.format(version=geckodriver_version,

os_=os_,

architecture=architecture,

compression=compression)

download_report_template = ("\t - downloading from '{0}' to '{1}'"

.format(url, zip_path))

def reporthoook(x, y, z):

global download_ok

percent_downloaded = '{0:.0%}'.format((x * y) / float(z))

sys.stdout.write('\r')

sys.stdout.write("{0} [{1}]".format(download_report_template,

percent_downloaded))

download_ok = percent_downloaded == '100%'

if download_ok:

sys.stdout.write(' OK')

sys.stdout.flush()

request.urlretrieve(url, zip_path, reporthoook)

print('')

if not download_ok:

print('\t - download failed!')

def _unzip(self, zip_path):

if zip_path.endswith('zip'):

zf = zipfile.ZipFile(zip_path)

else:

zf = tarfile.open(zip_path)

print("\t - extracting '{0}' to '{1}'."

.format(zip_path, self.build_dir))

zf.extractall(self.build_dir)

def _get_compression_suffix(self):

result = 'tar.gz'

if platform.platform().lower().startswith('win'):

result = 'zip'

return result

def run(self):

global geckodriver_version, geckodriver_checksums

if not geckodriver_version:

geckodriver_version = get_geckodriver_version()

file_name = 'geckodriver_{version}.{compression}'.format(version=geckodriver_version, compression=self._get_compression_suffix())

zip_path = os.path.join(tempfile.gettempdir(), file_name)

self._download(zip_path)

self._unzip(zip_path)

self.scripts = [os.path.join(self.build_dir, script) for script in

os.listdir(self.build_dir)]

build_scripts.run(self)

def finalize_options(self):

build_scripts.finalize_options(self)

"""Used to get geckodriver version and checksums from install options"""

# Fix an error when pip calls setup.py with the

# --single-version-externally-managed and it is not supported due to

# old setuptools version.

_svem = list(filter(lambda x: x[0] == 'single-version-externally-managed',

install.user_options))

if not _svem:

single_version_externally_managed = None

install.user_options.append(('single-version-externally-managed',

None, ""))

user_options = install.user_options + [

('geckodriver-version=', None, 'Geckodriver version'),

('geckodriver-checksums=', None, 'Geckodriver checksums'),

]

def initialize_options(self):

self.geckodriver_version = None

install.initialize_options(self)

def run(self):

global geckodriver_version

if self.geckodriver_version:

if not GECKODRIVER_VERSION_PATTERN.match(self.geckodriver_version):

raise Exception('Invalid --geckodriver-version={0}! '

'Must match /{1}/'

.format(self.geckodriver_version,

GECKODRIVER_VERSION_PATTERN.pattern))

if not StrictVersion(self.geckodriver_version) >= StrictVersion(OLDEST_SUPPORTED_VERSION):

raise Exception('Invalid --geckodriver-version={0}! '

'Minimum supported version is {1}'

.format(self.geckodriver_version,

OLDEST_SUPPORTED_VERSION))

geckodriver_version = self.geckodriver_version