# coding: utf8

"""

Speed tests

-----------

Note: this file is not named test_*.py as it is not part of the

test suite ran by pytest.

:copyright: (c) 2012 by Simon Sapin.

:license: BSD, see LICENSE for more details.

"""

from __future__ import unicode_literals, division

import sys

import os.path

import contextlib

import timeit

import functools

from cssutils import parseString

from .. import tokenizer

from ..css21 import CSS21Parser

from ..parsing import remove_whitespace

CSS_REPEAT = 4

TIMEIT_REPEAT = 3

TIMEIT_NUMBER = 20

def load_css():

filename = os.path.join(os.path.dirname(__file__),

'..', '..', 'docs', '_static', 'custom.css')

with open(filename, 'rb') as fd:

return b'\n'.join([fd.read()] * CSS_REPEAT)

# Pre-load so that I/O is not measured

CSS = load_css()

@contextlib.contextmanager

def install_tokenizer(name):

original = tokenizer.tokenize_flat

try:

tokenizer.tokenize_flat = getattr(tokenizer, name)

yield

finally:

tokenizer.tokenize_flat = original

def parse(tokenizer_name):

with install_tokenizer(tokenizer_name):

stylesheet = CSS21Parser().parse_stylesheet_bytes(CSS)

result = []

for rule in stylesheet.rules:

selector = rule.selector.as_css()

declarations = [

(declaration.name, len(list(remove_whitespace(declaration.value))))

for declaration in rule.declarations]

result.append((selector, declarations))

return result

parse_cython = functools.partial(parse, 'cython_tokenize_flat')

parse_python = functools.partial(parse, 'python_tokenize_flat')

def parse_cssutils():

stylesheet = parseString(CSS)

result = []

for rule in stylesheet.cssRules:

selector = rule.selectorText

declarations = [

(declaration.name, len(list(declaration.propertyValue)))

for declaration in rule.style.getProperties(all=True)]

result.append((selector, declarations))

return result

def check_consistency():

result = parse_python()

#import pprint

#pprint.pprint(result)

assert len(result) > 0

if tokenizer.cython_tokenize_flat:

assert parse_cython() == result

assert parse_cssutils() == result

version = '.'.join(map(str, sys.version_info[:3]))

print('Python {}, consistency OK.'.format(version))

def warm_up():

is_pypy = hasattr(sys, 'pypy_translation_info')

if is_pypy:

print('Warming up for PyPy...')

for i in range(80):

for i in range(10):

parse_python()

parse_cssutils()

sys.stdout.write('.')

sys.stdout.flush()

sys.stdout.write('\n')

def time(function):

seconds = timeit.Timer(function).repeat(TIMEIT_REPEAT, TIMEIT_NUMBER)

miliseconds = int(min(seconds) * 1000)

return miliseconds

def run():

if tokenizer.cython_tokenize_flat:

data_set = [

('tinycss + speedups ', parse_cython),

]

else:

print('Speedups are NOT available.')

data_set = []

data_set += [

('tinycss WITHOUT speedups', parse_python),

('cssutils ', parse_cssutils),

]

label, function = data_set.pop(0)

ref = time(function)

print('{} {} ms'.format(label, ref))

for label, function in data_set:

result = time(function)

print('{} {} ms {:.2f}x'.format(label, result, result / ref))

if __name__ == '__main__':

check_consistency()

warm_up()

run()