How to use the cssutils.log.setLevel function in cssutils

def setUp(self):
        cssutils.log.setLevel(logging.ERROR)
        self.base_path = os.path.dirname(os.path.abspath(__file__))
        self.output_path = os.path.join(self.base_path, self.TEST_PATH)
        shutil.rmtree(self.output_path, True)
        os.makedirs(self.output_path)
        self.pwd = os.getcwd()
        os.chdir(self.output_path)
        sys.stdout = StringIO()
        sys.stderr = StringIO()

# encoding: utf-8
from __future__ import unicode_literals, print_function

import logging; import  cssutils; cssutils.log.setLevel(logging.FATAL)

from emails.loader.helpers import (guess_charset, guess_text_charset, decode_text, guess_html_charset, RULES_U)


def test_re_rules():
    assert RULES_U.re_is_http_equiv.findall('http-equiv="Content-Type" content="text/html; charset=UTF-8"')


def test_guess_charset():
    assert guess_charset(headers={'content-type': 'text/html; charset=utf-8'}, html='') == 'utf-8'

    assert guess_charset(headers=None, html='') == 'xxx-N'

    html = """"""
    assert guess_charset(headers=None, html=html) == 'UTF-8'
    assert guess_text_charset(html, is_html=True) == 'UTF-8'

def __call__(self, data, **metadata):
        cssutils.log.setLevel(logging.CRITICAL)
        cssutils.ser.prefs.keepComments = True
        cssutils.ser.prefs.omitLastSemicolon = False
        cssutils.ser.prefs.indentClosingBrace = False
        cssutils.ser.prefs.validOnly = False

        sheet = cssutils.parseString(data)
        beautified = sheet.cssText

        return "CSS", format_text(beautified)

import pkg_resources

import cssutils
from flask import Flask, g
from flask_wtf import CSRFProtect
from flask_login import current_user
from flask_principal import Principal, UserNeed, identity_loaded

from flaskapp.lib import template_helpers
from flaskapp.meta import mail, db, lm
from flaskapp.models import User
from flaskapp.views import content, auth


# suppress cssutils warning messages
cssutils.log.setLevel(logging.CRITICAL)


# ================================
# App creator method
# ================================
def create_app(extra_config=None):
    """Create Flask app for Flaskapp
    """
    app = Flask('flaskapp',
                template_folder='templates',
                static_folder='static')

    app.config.from_object('config')
    app.config.update(**(extra_config or {}))
    app.before_request(before_request)

"""
Utility to parse and save CSS
"""
import cssutils
import logging
import re

from spade import model

# Ensure that warnings for CSS properties are disabled: cssutils throws
# warnings when properties are not recognized. It also only recognizes up to
# CSS2, and a few CSS3 properties. Most prefixed properties will cause warnings
# We're only using cssutils to iterate over rules, so this is fine
cssutils.log.setLevel(logging.FATAL)


class CSSParser(object):
    def parse_rule(self, rule):
        """
        Returns a tuple containing the rule's selector and parsed properties
        Example: (selector, { property: (prefix, unprefixed_name, value), })
        """
        selector_string = " ".join([s.selectorText for s in rule.selectorList])

        # Get property strings
        properties = []
        for property in rule.style:
            properties.append((property.name, property.value))

        # Create the dictionary that gives us easy access to the components of

import logging
import cssutils

cssutils.log.setLevel(logging.CRITICAL)


class PropsDict(dict):
    '''
    A dictionary with properties.
    Shows properties if no record inside.
    '''
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self._properties = {}

    def __setitem__(self, key, value):
        super().__setitem__(key, value)

    def __repr__(self):
        if self == {}:

def _parse_css(self, data):
            from cssutils.css import CSSRule
            from cssutils import CSSParser, log
            log.setLevel(logging.WARN)
            def get_style_rules_from_import(import_rule):
                ans = []
                if not import_rule.styleSheet:
                    return ans
                rules = import_rule.styleSheet.cssRules
                for rule in rules:
                    if rule.type == CSSRule.IMPORT_RULE:
                        ans.extend(get_style_rules_from_import(rule))
                    elif rule.type in (CSSRule.FONT_FACE_RULE,
                            CSSRule.STYLE_RULE):
                        ans.append(rule)
                return ans

            logging.debug('Parsing', self.href, '...')
            data = self.oeb.decode(data)
            data = self.oeb.css_preprocessor(data, add_namespace=True)

from xml.sax.saxutils import escape


from bs4 import BeautifulSoup, NavigableString
from cssutils import parseString, log, css as cssutils_css

from .base import (
    BaseReader, BaseWriter, CaptionSet, CaptionList, Caption, CaptionNode,
    DEFAULT_LANGUAGE_CODE)
from .exceptions import (
    CaptionReadNoCaptions, CaptionReadSyntaxError, InvalidInputError)
from .geometry import Layout, Alignment, Padding, Size


# change cssutils default logging
log.setLevel(FATAL)


SAMI_BASE_MARKUP = '''

    

from __future__ import print_function, division
import webcolors
from xtermcolor import colorize
from wcag_zoo.utils import WCAGCommand, get_applicable_styles, nice_console_text
from decimal import Decimal as D

import logging
import cssutils
cssutils.log.setLevel(logging.CRITICAL)

WCAG_LUMINOCITY_RATIO_THRESHOLD = {
    "AA": {
        'normal': 4.5,
        'large': 3,
    },
    "AAA": {
        'normal': 7,
        'large': 4.5,
    }
}

TECHNIQUE = {
    "AA": {
        'normal': "G18",
        'large': "G145",

def read_font_fule(self, basedir, css):
        from PyQt5.Qt import QFontDatabase
        import cssutils
        cssutils.log.setLevel(logging.ERROR)
        try:
            sheet = cssutils.parseString(css, validate=False)
        except:
            return
        for rule in sheet.cssRules:
            try:
                s = rule.style
                src = s.getProperty('src').propertyValue[0].uri
                font_family = s.getProperty('font-family').propertyValue[0].value
            except:
                continue
            if not src or not font_family:
                continue
            font_file = os.path.normcase(os.path.abspath(os.path.join(basedir,
                src)))
            if font_file not in self.added_fonts: