How to use the cssutils.ser.prefs.useMinified function in cssutils

To help you get started, we’ve selected a few cssutils examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

github jorgebastida / cssbuster / cssbuster.py View on Github external
parser.error("You must provide a css file ")
    elif len(args) == 1:
        parser.error(("You must provide the relative path between "
                      "the css and the images."))

    css_path = os.path.basename(args[0])
    img_rel_path = args[1]

    # Configure the logger
    log = logging.getLogger('csscache')
    handler = logging.StreamHandler(sys.stderr)
    handler.setLevel(logging.ERROR)
    log.addHandler(handler)

    if options.minified:
        cssutils.ser.prefs.useMinified()

    # Create the parser
    parser = cssutils.CSSParser(log=log,
                                raiseExceptions=True,
                                parseComments=not options.minified,
                                validate=False)
    try:
        # Parse the original file
        sheet = parser.parseFile(args[0])
    except Exception, e:
        sys.stderr.write('Error: %s %s\n' % (css_path, e.args[0]))
        sys.exit(1)

    # Replace all the urls
    replacer = partial(cache_bust_replacer, options, css_path, img_rel_path)
    cssutils.replaceUrls(sheet, replacer, ignoreImportRules=True)
github kovidgoyal / calibre / src / cssutils / script.py View on Github external
directory to save files to
        saveparsed
            save literal CSS from server or save the parsed CSS
        minified
            save minified CSS

        Both parsed and minified (which is also parsed of course) will
        loose information which cssutils is unable to understand or where
        it is simple buggy. You might to first save the raw version before
        parsing of even minifying it.
        """
        msg = 'parsed'
        if saveraw:
            msg = 'raw'
        if minified:
            cssutils.ser.prefs.useMinified()
            msg = 'minified'

        inlines = 0
        for i, sheet in enumerate(self.stylesheetlist):
            url = sheet.href
            if not url:
                inlines += 1
                url = u'%s_INLINE_%s.css' % (self._filename, inlines)

            # build savepath
            scheme, loc, path, query, fragment = urlparse.urlsplit(url)
            # no absolute path
            if path and path.startswith('/'):
                path = path[1:]
            path = os.path.normpath(path)
            path, fn = os.path.split(path)
github kovidgoyal / calibre / src / cssutils / script.py View on Github external
if path:
        src = cssutils.parseFile(path, encoding=sourceencoding)
    elif url:
        src = cssutils.parseUrl(url, encoding=sourceencoding)
    else:
        sys.exit('Path or URL must be given')

    result = cssutils.resolveImports(src)
    result.encoding = targetencoding
    cssutils.log.info(u'Using target encoding: %r' % targetencoding, neverraise=True)

    if minify:
        # save old setting and use own serializer
        oldser = cssutils.ser
        cssutils.setSerializer(cssutils.serialize.CSSSerializer())
        cssutils.ser.prefs.useMinified()
        cssText = result.cssText
        cssutils.setSerializer(oldser)
    else:
        cssText = result.cssText
    
    return cssText
github clevercss / clevercss / clevercss / ccss.py View on Github external
'source and target file "%s".' % fname)
            sys.exit(2)
        elif options.no_overwrite and os.path.exists(target):
            sys.stderr.write('File exists (and --no-overwrite was used) "%s".' % target)
            sys.exit(3)

        src = open(fname)
        try:
            try:
                converted = clevercss.convert(src.read(), fname=fname)
            except (ParserError, EvalException) as e:
                sys.stderr.write('Error in file %s: %s\n' % (fname, e))
                sys.exit(1)
            if options.minified:
                css = cssutils.CSSParser().parseString(converted)
                cssutils.ser.prefs.useMinified()
                converted = css.cssText
            dst = open(target, 'w')
            try:
                print('Writing output to %s...' % target)
                dst.write(converted)
            finally:
                dst.close()
        finally:
            src.close()
github palexu / send2kindle / cssutils / scripts / cssparse.py View on Github external
help='minify parsed CSS', default=False)
    p.add_option('-d', '--debug', action='store_true', dest='debug',
        help='activate debugging output')

    (options, params) = p.parse_args(args)

    if not params and not options.url:
        p.error("no filename given")

    if options.debug:
        p = cssutils.CSSParser(loglevel=logging.DEBUG)
    else:
        p = cssutils.CSSParser()

    if options.minify:
        cssutils.ser.prefs.useMinified()

    if options.string:
        sheet = p.parseString(u''.join(params), encoding=options.encoding)
        print sheet.cssText
    elif options.url:
        sheet = p.parseUrl(options.url, encoding=options.encoding)
        print sheet.cssText
    else:
        for filename in params:
            sys.stderr.write('=== CSS FILE: "%s" ===\n' % filename)
            sheet = p.parseFile(filename, encoding=options.encoding)
            print sheet.cssText
            print
            sys.stderr.write('\n')
github nate-parrott / m.py / m.py View on Github external
def _minified():
			href = self.base_url if self.base_url != '' else None
			sheet = cssutils.parseString(css, href=href)
			sheet = cssutils.resolveImports(sheet)
			cssutils.ser.prefs.useMinified()
			return sheet.cssText
		return self.cached(css.encode('utf-8'), _minified)
github nueverest / blowdrycss / blowdrycss / filehandler.py View on Github external
in code called after this method is called.

        :type css_text: str

        :param css_text: Text containing the CSS to be written to the file.
        :return: None

        **Example:**

        >>> css_text = '.margin-top-50px { margin-top: 3.125em }'
        >>> css_file = CSSFile()
        >>> css_file.minify(css_text=css_text)

        """
        parse_string = parseString(css_text)
        ser.prefs.useMinified()                                     # Enable minification.
        file_path = get_file_path(
            file_directory=self.file_directory,
            file_name=self.file_name,
            extension=str('.min' + self.extension)                  # prepend '.min'
        )
        with open(file_path, 'w') as css_file:
            css_file.write(parse_string.cssText.decode('utf-8'))
        ser.prefs.useDefaults()                                     # Disable minification.