Ubuntu Manpage: libsass - libsass Documentation

Provided by: python3-libsass_0.21.0-1_amd64

NAME

       libsass - libsass Documentation

       This  package  provides  a  simple  Python  extension module sass which is binding LibSass
       (written in C/C++ by Hampton Catlin and Aaron Leung).  It's very straightforward and there
       isn't  any  headache  related Python distribution/deployment.  That means you can add just
       libsass into your setup.py's install_requires list or requirements.txt file.

       It currently supports CPython 2.6, 2.7, 3.5--3.7, and PyPy 2.3+!

FEATURES

       • You don't need any Ruby/Node.js stack at all, for development or deployment either.

       • Fast. (LibSass is written in C++.)

       • Simple API.  See example code for details.

       • Custom functions.

       • @import callbacks.

       • Support both tabbed (Sass) and braces (SCSS) syntax.

       • WSGI middleware for ease of development.  It automatically compiles Sass/SCSS files  for
         each request.  See also sassutils.wsgi for details.

       • setuptools/distutils  integration.   You  can  build  all Sass/SCSS files using setup.py
         build_sass command.  See also sassutils.distutils for details.

       • Works also on PyPy.

       • Provides prebuilt wheel (PEP 427) binaries for Windows and Mac.

INSTALL

       It's available on PyPI, so you can install it using pip:

          $ pip install libsass

       NOTE:
          libsass requires some features introduced by the recent C++ standard.  You need  a  C++
          compiler that support those features.  See also libsass project's README file.

EXAMPLES

   Compile a String of Sass to CSS
       >>> import sass
       >>> sass.compile(string='a { b { color: blue; } }')
       'a b {\n  color: blue; }\n'

   Compile a Directory of Sass Files to CSS
       >>> import sass
       >>> import os
       >>> os.mkdir('css')
       >>> os.mkdir('sass')
       >>> scss = """\
       ... $theme_color: #cc0000;
       ... body {
       ...     background-color: $theme_color;
       ... }
       ... """
       >>> with open('sass/example.scss', 'w') as example_scss:
       ...      example_scss.write(scss)
       ...
       >>> sass.compile(dirname=('sass', 'css'), output_style='compressed')
       >>> with open('css/example.css') as example_css:
       ...     print(example_css.read())
       ...
       body{background-color:#c00}

USER'S GUIDE

Using with Flask
This guide explains how to use libsass with the Flask web framework. sassutils package
provides several tools that can be integrated into web applications written in Flask.

Contents
• Using with Flask

• Directory layout

• Defining manifest

• Building Sass/SCSS for each request

• Building Sass/SCSS for each deployment

Directory layout
Imagine the project contained in such directory layout:

• setup.py

• myapp/

• __init__.py

• static/

• sass/

• css/

• templates/

Sass/SCSS files will go inside myapp/static/sass/ directory. Compiled CSS files will go
inside myapp/static/css/ directory. CSS files can be regenerated, so add
myapp/static/css/ into your ignore list like .gitignore or .hgignore.

Defining manifest
The sassutils defines a concept named manifest. Manifest is the build settings of
Sass/SCSS. It specifies some paths related to building Sass/SCSS:

• The path of the directory which contains Sass/SCSS source files.

• The path of the directory which the compiled CSS files will go.

• The path, exposed to HTTP (through WSGI), of the directory that will contain the
compiled CSS files.

Every package may have its own manifest. Paths have to be relative to the path of the
package.

For example, in the above project, the package name is myapp. The path of the package is
myapp/. The path of the Sass/SCSS directory is static/sass/ (relative to the package
directory). The path of the CSS directory is static/css/. The exposed path is
/static/css.

These settings can be represented as the following manifests:

{
'myapp': ('static/sass', 'static/css', '/static/css')
}

As you can see the above, the set of manifests are represented in dictionary, in which the
keys are packages names and the values are tuples of paths.

Building Sass/SCSS for each request
SEE ALSO:

Flask --- Hooking in WSGI Middlewares
The section which explains how to integrate WSGI middlewares to Flask.

Flask --- flask:app-dispatch
The documentation which explains how Flask dispatches each request internally.

In development, manually building Sass/SCSS files for each change is a tedious task.
SassMiddleware makes the web application build Sass/SCSS files for each request
automatically. It's a WSGI middleware, so it can be plugged into the web app written in
Flask.

SassMiddleware takes two required parameters:

• The WSGI-compliant callable object.

• The set of manifests represented as a dictionary.

So:

from flask import Flask
from sassutils.wsgi import SassMiddleware

app = Flask(__name__)

app.wsgi_app = SassMiddleware(app.wsgi_app, {
'myapp': ('static/sass', 'static/css', '/static/css')
})

And then, if you want to link a compiled CSS file, use the url_for() function:

NOTE:
The linked filename is style.scss.css, not just style.scss. All compiled filenames
have trailing .css suffix.

Building Sass/SCSS for each deployment
NOTE:
This section assumes that you use setuptools for deployment.

REFERENCES

   pysassc --- SassC compliant command line interface
       This provides SassC compliant CLI executable named pysassc:

          $ pysassc
          Usage: pysassc [options] SCSS_FILE [CSS_FILE]

       There are options as well:

       -t <style>, --style <style>
              Coding style of  the  compiled  result.   The  same  as  sass.compile()  function's
              output_style keyword argument.  Default is nested.

       -s <style>, --output-style <style>
              Alias for -t / --style.

              Deprecated since version 0.11.0.

       -I <dir>, --include-path <dir>
              Optional directory path to find @imported (S)CSS files.  Can be multiply used.

       -m, -g, --sourcemap
              Emit source map.  Requires the second argument (output CSS filename).  The filename
              of source map will be the output CSS filename followed by .map.

              New in version 0.4.0.

       -p, --precision
              Set the precision for numbers. Default is 5.

              New in version 0.7.0.

       --source-comments
              Include debug info in output.

              New in version 0.11.0.

       --sourcemap-file
              Output file for source map

              New in version 0.17.0.

       --sourcemap-contents
              Embed sourcesContent in source map.

              New in version 0.17.0.

       --sourcemap-embed
              Embed sourceMappingUrl as data URI

              New in version 0.17.0.

       --omit-sourcemap-url
              Omit source map URL comment from output

              New in version 0.17.0.

       --sourcemap-root
              Base path, will be emitted to sourceRoot in source-map as is

              New in version 0.17.0.

       -v, --version
              Prints the program version.

       -h, --help
              Prints the help message.

   sass --- Binding of libsass
       This simple C extension module provides a very simple binding of libsass, which is written
       in C/C++.  It contains only one function and one exception type.

       >>> import sass
       >>> sass.compile(string='a { b { color: blue; } }')
       'a b {
         color: blue; }
       '

       exception sass.CompileError(msg)
              The   exception   type   that   is  raised  by  compile().   It  is  a  subtype  of
              exceptions.ValueError.

       sass.MODES = frozenset({'dirname', 'filename', 'string'})
              (frozenset) The set of keywords compile() can take.

       sass.OUTPUT_STYLES = {'compact': 2, 'compressed': 3, 'expanded': 1, 'nested': 0}
              (collections.abc.Mapping) The dictionary of output styles.  Keys  are  output  name
              strings, and values are flag integers.

       sass.SOURCE_COMMENTS = {'default': 1, 'line_numbers': 1, 'map': 2, 'none': 0}
              (collections.abc.Mapping)  The dictionary of source comments styles.  Keys are mode
              names, and values are corresponding flag integers.

              New in version 0.4.0.

              Deprecated since version 0.6.0.

       class sass.SassColor(r, g, b, a)

       class sass.SassError(msg)

       class sass.SassFunction(name, arguments, callable_)
              Custom  function  for  Sass.   It  can  be  instantiated  using  from_lambda()  and
              from_named_function() as well.

              Parameters

                     • name (str) -- the function name

                     • arguments (collections.abc.Sequence) -- the argument names

                     • callable (collections.abc.Callable) -- the actual function to be called

              New in version 0.7.0.

              classmethod from_lambda(name, lambda_)
                     Make  a  SassFunction  object from the given lambda_ function.  Since lambda
                     functions don't have their name, it need its name as  well.   Arguments  are
                     automatically inspected.

                     Parameters

                            • name (str) -- the function name

                            • lambda  (types.LambdaType)  --  the  actual  lambda  function to be
                              called

                     Returns
                            a custom function wrapper of the lambda_ function

                     Return type
                            SassFunction

              classmethod from_named_function(function)
                     Make a SassFunction object from  the  named  function.   Function  name  and
                     arguments are automatically inspected.

                     Parameters
                            function (types.FunctionType) -- the named function to be called

                     Returns
                            a custom function wrapper of the function

                     Return type
                            SassFunction

              property signature
                     Signature string of the function.

       class sass.SassList(items, separator, bracketed=False)

       class sass.SassMap(*args, **kwargs)
              Because  sass  maps  can  have mapping types as keys, we need an immutable hashable
              mapping type.

              New in version 0.7.0.

       class sass.SassNumber(value, unit)

       class sass.SassWarning(msg)

       sass.and_join(strings)
              Join the given strings by commas with last ' and ' conjunction.

              >>> and_join(['Korea', 'Japan', 'China', 'Taiwan'])
              'Korea, Japan, China, and Taiwan'

              Parameters
                     strings -- a list of words to join

              Returns
                     a joined string

              Return type
                     str, basestring

       sass.compile(**kwargs)
              There are three modes of parameters  compile()  can  take:  string,  filename,  and
              dirname.

              The  string  parameter  is  the  most basic way to compile Sass.  It simply takes a
              string of Sass code, and then returns a compiled CSS string.

              Parameters

                     • string (str) -- Sass source code to compile.  it's exclusive  to  filename
                       and dirname parameters

                     • output_style  (str)  --  an  optional coding style of the compiled result.
                       choose one of: 'nested' (default), 'expanded', 'compact', 'compressed'

                     • source_comments (bool) -- whether to  add  comments  about  source  lines.
                       False by default

                     • source_map_contents (bool) -- embed include contents in map

                     • source_map_embed (bool) -- embed sourceMappingUrl as data URI

                     • omit_source_map_url (bool) -- omit source map URL comment from output

                     • source_map_root (str) -- base path, will be emitted in source map as is

                     • include_paths  (collections.abc.Sequence)  -- an optional list of paths to
                       find @imported Sass/CSS source files

                     • precision (int) -- optional precision for numbers. 5 by default.

                     • custom_functions (set, collections.abc.Sequence,  collections.abc.Mapping)
                       --  optional mapping of custom functions.  see also below custom functions
                       description

                     • custom_import_extensions -- (ignored, for backward compatibility)

                     • indented (bool) -- optional declaration that the string is Sass, not  SCSS
                       formatted. False by default

                     • importers  (collections.abc.Callable) -- optional callback functions.  see
                       also below importer callbacks description

              Returns
                     the compiled CSS string

              Return type
                     str

              Raises sass.CompileError -- when it fails for any reason  (for  example  the  given
                     Sass has broken syntax)

              The  filename  is  the most commonly used way.  It takes a string of Sass filename,
              and then returns a compiled CSS string.

              Parameters

                     • filename (str) -- the filename of  Sass  source  code  to  compile.   it's
                       exclusive to string and dirname parameters

                     • output_style  (str)  --  an  optional coding style of the compiled result.
                       choose one of: 'nested' (default), 'expanded', 'compact', 'compressed'

                     • source_comments (bool) -- whether to  add  comments  about  source  lines.
                       False by default

                     • source_map_filename  (str)  -- use source maps and indicate the source map
                       output filename.  None means not using source maps.  None by default.

                     • source_map_contents (bool) -- embed include contents in map

                     • source_map_embed (bool) -- embed sourceMappingUrl as data URI

                     • omit_source_map_url (bool) -- omit source map URL comment from output

                     • source_map_root (str) -- base path, will be emitted in source map as is

                     • include_paths (collections.abc.Sequence) -- an optional list of  paths  to
                       find @imported Sass/CSS source files

                     • precision (int) -- optional precision for numbers. 5 by default.

                     • custom_functions  (set, collections.abc.Sequence, collections.abc.Mapping)
                       -- optional mapping of custom functions.  see also below custom  functions
                       description

                     • custom_import_extensions -- (ignored, for backward compatibility)

                     • importers  (collections.abc.Callable) -- optional callback functions.  see
                       also below importer callbacks description

              Returns
                     the compiled CSS string, or a pair of the compiled CSS string and the source
                     map string if source_map_filename is set

              Return type
                     str, tuple

              Raises

                     • sass.CompileError  --  when it fails for any reason (for example the given
                       Sass has broken syntax)

                     • exceptions.IOError -- when the filename doesn't exist or cannot be read

              The dirname is useful for automation.  It takes a pair of paths.  The first of  the
              dirname  pair  refers  the  source directory, contains several Sass source files to
              compiled.  Sass source files can be nested in directories.  The second of the  pair
              refers the output directory that compiled CSS files would be saved.  Directory tree
              structure of the source directory will be maintained in  the  output  directory  as
              well.  If dirname parameter is used the function returns None.

              Parameters

                     • dirname  (tuple) -- a pair of (source_dir, output_dir).  it's exclusive to
                       string and filename parameters

                     • output_style (str) -- an optional coding style  of  the  compiled  result.
                       choose one of: 'nested' (default), 'expanded', 'compact', 'compressed'

                     • source_comments  (bool)  --  whether  to  add comments about source lines.
                       False by default

                     • source_map_contents (bool) -- embed include contents in map

                     • source_map_embed (bool) -- embed sourceMappingUrl as data URI

                     • omit_source_map_url (bool) -- omit source map URL comment from output

                     • source_map_root (str) -- base path, will be emitted in source map as is

                     • include_paths (collections.abc.Sequence) -- an optional list of  paths  to
                       find @imported Sass/CSS source files

                     • precision (int) -- optional precision for numbers. 5 by default.

                     • custom_functions  (set, collections.abc.Sequence, collections.abc.Mapping)
                       -- optional mapping of custom functions.  see also below custom  functions
                       description

                     • custom_import_extensions -- (ignored, for backward compatibility)

              Raises sass.CompileError  --  when  it  fails for any reason (for example the given
                     Sass has broken syntax)

              The custom_functions parameter can take three types of forms:

              set/Sequence of SassFunctions
                 It is the most general form.  Although pretty verbose, it can take any  kind  of
                 callables like type objects, unnamed functions, and user-defined callables.

                     sass.compile(
                         ...,
                         custom_functions={
                             sass.SassFunction('func-name', ('$a', '$b'), some_callable),
                             ...
                         }
                     )

              Mapping of names to functions
                     Less  general,  but  easier-to-use  form.  Although it's not it can take any
                     kind of callables, it can take any kind of  functions  defined  using  def/‐
                     lambda  syntax.   It  cannot take callables other than them since inspecting
                     arguments is not always available for every kind of callables.

                        sass.compile(
                            ...,
                            custom_functions={
                                'func-name': lambda a, b: ...,
                                ...
                            }
                        )

              set/Sequence of named functions
                 Not general, but the easiest-to-use form for named functions.  It can take  only
                 named  functions,  defined  using  def.   It  cannot take lambdas sinc names are
                 unavailable for them.

                     def func_name(a, b):
                         return ...

                     sass.compile(
                         ...,
                         custom_functions={func_name}
                     )

              Newer versions of libsass allow developers to define callbacks  to  be  called  and
              given  a chance to process @import directives. You can define yours by passing in a
              list of callables via the importers parameter. The  callables  must  be  passed  as
              2-tuples in the form:

                 (priority_int, callback_fn)

              A  priority  of  zero  is  acceptable;  priority determines the order callbacks are
              attempted.

              These callbacks can accept one or two string arguments. The first argument  is  the
              path  that  was  passed to the @import directive; the second (optional) argument is
              the previous resolved path, where the @import directive was  found.  The  callbacks
              must  either  return  None to indicate the path wasn't handled by that callback (to
              continue with others or fall back on internal libsass filesystem  behaviour)  or  a
              list of one or more tuples, each in one of three forms:

              • A 1-tuple representing an alternate path to handle internally; or,

              • A  2-tuple  representing  an alternate path and the content that path represents;
                or,

              • A  3-tuple  representing  the  same  as  the  2-tuple  with  the  addition  of  a
                "sourcemap".

              All tuple return values must be strings. As a not overly realistic example:

                 def my_importer(path, prev):
                     return [(path, '#' + path + ' { color: red; }')]

                 sass.compile(
                         ...,
                         importers=[(0, my_importer)]
                     )

              Now,  within  the style source, attempting to @import 'button'; will instead attach
              color: red as a property of an element with the imported name.

              New in version 0.4.0: Added source_comments and source_map_filename parameters.

              Changed in version 0.6.0: The source_comments parameter becomes to take  only  bool
              instead of str.

              Deprecated  since  version 0.6.0: Values like 'none', 'line_numbers', and 'map' for
              the source_comments parameter are deprecated.

              New in version 0.7.0: Added precision parameter.

              New in version 0.7.0: Added custom_functions parameter.

              New in version 0.11.0: source_map_filename no longer implies source_comments.

              New   in   version    0.17.0:    Added    source_map_contents,    source_map_embed,
              omit_source_map_url, and source_map_root parameters.

              New  in  version 0.18.0: The importer callbacks can now take a second argument, the
              previously- resolved path, so that importers can do relative path resolution.

   sassutils --- Additional utilities related to Sass
       This package provides several additional  utilities  related  to  Sass  which  depends  on
       libsass core (sass module).

   sassutils.builder --- Build the whole directory
       class       sassutils.builder.Manifest(sass_path,      css_path=None,      wsgi_path=None,
       strip_extension=None)
              Building manifest of Sass/SCSS.

              Parameters

                     • sass_path (str, basestring) -- the path of  the  directory  that  contains
                       Sass/SCSS source files

                     • css_path  (str, basestring) -- the path of the directory to store compiled
                       CSS files

                     • strip_extension (bool) -- whether to remove the original file extension

              build(package_dir, output_style='nested')
                     Builds the Sass/SCSS files in the specified sass_path.  It  finds  sass_path
                     and locates css_path as relative to the given package_dir.

                     Parameters

                            • package_dir (str, basestring) -- the path of package directory

                            • output_style  (str)  --  an  optional  coding style of the compiled
                              result.  choose one of: 'nested' (default), 'expanded',  'compact',
                              'compressed'

                     Returns
                            the set of compiled CSS filenames

                     Return type
                            frozenset

                     New in version 0.6.0: The output_style parameter.

              build_one(package_dir, filename, source_map=False)
                     Builds one Sass/SCSS file.

                     Parameters

                            • package_dir (str, basestring) -- the path of package directory

                            • filename  (str,  basestring) -- the filename of Sass/SCSS source to
                              compile

                            • source_map (bool) -- whether to use source maps.  if True  it  also
                              write  a source map to a filename followed by .map suffix.  default
                              is False

                     Returns
                            the filename of compiled CSS

                     Return type
                            str, basestring

                     New in version 0.4.0: Added optional source_map parameter.

              resolve_filename(package_dir, filename)
                     Gets a proper full relative path of Sass source and CSS source that will  be
                     generated, according to package_dir and filename.

                     Parameters

                            • package_dir (str, basestring) -- the path of package directory

                            • filename  (str,  basestring) -- the filename of Sass/SCSS source to
                              compile

                     Returns
                            a pair of (sass, css) path

                     Return type
                            tuple

              unresolve_filename(package_dir, filename)
                     Retrieves the probable source path from the output filename.  Pass in a .css
                     path to get out a .scss path.

                     Parameters

                            • package_dir (str) -- the path of the package directory

                            • filename (str) -- the css filename

                     Returns
                            the scss filename

                     Return type
                            str

       sassutils.builder.SUFFIXES = frozenset({'sass', 'scss'})
              (frozenset) The set of supported filename suffixes.

       sassutils.builder.SUFFIX_PATTERN = re.compile('[.](sass|scss)$')
              (re.RegexObject)  The  regular  expression  pattern  which  matches to filenames of
              supported SUFFIXES.

       sassutils.builder.build_directory(sass_path,       css_path,        output_style='nested',
       _root_sass=None, _root_css=None, strip_extension=False)
              Compiles all Sass/SCSS files in path to CSS.

              Parameters

                     • sass_path  (str,  basestring)  -- the path of the directory which contains
                       source files to compile

                     • css_path (str, basestring) -- the path of the directory compiled CSS files
                       will go

                     • output_style  (str)  --  an  optional coding style of the compiled result.
                       choose one of: 'nested' (default), 'expanded', 'compact', 'compressed'

              Returns
                     a dictionary of source filenames to compiled CSS filenames

              Return type
                     collections.abc.Mapping

              New in version 0.6.0: The output_style parameter.

   sassutils.distutils --- setuptools/distutils integration
       This module provides extensions (and some magical monkey-patches, sorry) of  the  standard
       distutils and setuptools (now it's named Distribute) for libsass.

       To use this, add libsass into setup_requires (not install_requires) option of the setup.py
       script:

          from setuptools import setup

          setup(
              # ...,
              setup_requires=['libsass >= 0.6.0']
          )

       It will adds build_sass command to the setup.py script:

          $ python setup.py build_sass

       This commands builds Sass/SCSS files to compiled CSS files of the project  and  makes  the
       package archive (made by sdist, bdist, and so on) to include these compiled CSS files.

       To  set  the  directory  of Sass/SCSS source files and the directory to store compiled CSS
       files, specify sass_manifests option:

          from setuptools import find_packages, setup

          setup(
              name='YourPackage',
              packages=find_packages(),
              sass_manifests={
                  'your.webapp': ('static/sass', 'static/css')
              },
              setup_requires=['libsass >= 0.6.0']
          )

       The option should be a mapping of package names to pairs of paths, e.g.:

          {
              'package': ('static/sass', 'static/css'),
              'package.name': ('static/scss', 'static')
          }

       The option can also be a mapping of package names to manifest dictionaries:

          {
              'package': {
                  'sass_path': 'static/sass',
                  'css_path': 'static/css',
                  'strip_extension': True,
              },
          }

       New in version 0.15.0: Added strip_extension so a.scss is compiled  to  a.css  instead  of
       a.scss.css.  This option will default to True in the future.

       New in version 0.6.0: Added --output-style/-s option to build_sass command.

       class sassutils.distutils.build_sass(dist, **kw)
              Builds Sass/SCSS files to CSS files.

              finalize_options()
                     Set  final  values  for all the options that this command supports.  This is
                     always called as late as possible, ie.  after any  option  assignments  from
                     the  command-line  or from other commands have been done.  Thus, this is the
                     place to code option dependencies: if 'foo' depends on  'bar',  then  it  is
                     safe  to  set  'foo' from 'bar' as long as 'foo' still has the same value it
                     was assigned in 'initialize_options()'.

                     This method must be implemented by all command classes.

              get_package_dir(package)
                     Returns the directory, relative to the top of the source distribution, where
                     package  package  should  be  found  (at  least according to the package_dir
                     option, if any).

                     Copied from distutils.command.build_py.get_package_dir() method.

              initialize_options()
                     Set default values for all the options that  this  command  supports.   Note
                     that  these  defaults  may  be  overridden  by  other commands, by the setup
                     script, by config files, or by the command-line.   Thus,  this  is  not  the
                     place     to     code     dependencies     between    options;    generally,
                     'initialize_options()' implementations are just a bunch of "self.foo = None"
                     assignments.

                     This method must be implemented by all command classes.

              run()  A  command's  raison  d'etre:  carry  out  the  action it exists to perform,
                     controlled by the options initialized in 'initialize_options()',  customized
                     by other commands, the setup script, the command-line, and config files, and
                     finalized in  'finalize_options()'.   All  terminal  output  and  filesystem
                     interaction should be done by 'run()'.

                     This method must be implemented by all command classes.

       sassutils.distutils.validate_manifests(dist, attr, value)
              Verifies    that    value    is    an    expected    mapping    of    package    to
              sassutils.builder.Manifest.

   sassutils.wsgi --- WSGI middleware for development purpose
       class sassutils.wsgi.SassMiddleware(app, manifests, package_dir={}, error_status='200 OK')
              WSGI middleware for development purpose.  Every time a CSS file  has  requested  it
              finds a matched Sass/SCSS source file and then compiled it into CSS.

              It shows syntax errors in three ways:

              Heading comment
                     The  result  CSS  includes detailed error message in the heading CSS comment
                     e.g.:

                        /*
                        Error: invalid property name
                        */

              Red text in body:before
                     The result CSS draws detailed error message in :before pseudo-class of  body
                     element e.g.:

                        body:before {
                            content: 'Error: invalid property name';
                            color: maroon;
                            background-color: white;
                        }

                     In  most cases you could be aware of syntax error by refreshing your working
                     document because it will removes all other styles  and  leaves  only  a  red
                     text.

              logging
                     It    logs    syntax    errors    if    exist    during    compilation    to
                     sassutils.wsgi.SassMiddleware logger with level ERROR.

                     To enable this:

                        from logging import Formatter, StreamHandler, getLogger
                        logger = getLogger('sassutils.wsgi.SassMiddleware')
                        handler = StreamHandler(level=logging.ERROR)
                        formatter = Formatter(fmt='*' * 80 + '\n%(message)s\n' + '*' * 80)
                        handler.setFormatter(formatter)
                        logger.addHandler(handler)

                     Or simply:

                        import logging
                        logging.basicConfig()

              Parameters

                     • app (collections.abc.Callable) -- the WSGI application to wrap

                     • manifests (collections.abc.Mapping) -- build settings.  the same format to
                       setup.py script's sass_manifests option

                     • package_dir (collections.abc.Mapping) -- optional mapping of package names
                       to directories.  the same format to setup.py script's package_dir option

              Changed in version 0.4.0: It creates also source map files with filenames  followed
              by .map suffix.

              New  in  version  0.8.0:  It  logs  syntax  errors  if  exist during compilation to
              sassutils.wsgi.SassMiddleware logger with level ERROR.

              static quote_css_string(s)
                     Quotes a string as CSS string literal.

CREDIT

       Hong Minhee wrote this Python binding of LibSass.

       Hampton Catlin and Aaron Leung wrote LibSass, which is portable  C/C++  implementation  of
       Sass.

       Hampton   Catlin   originally  designed  Sass  language  and  wrote  the  first  reference
       implementation of it in Ruby.

       The above three  are all distributed under MIT license.

OPEN SOURCE

       GitHub (Git repository + issues)
              https://github.com/sass/libsass-python

       Azure Pipelines CI (linux + windows)
              https://dev.azure.com/asottile/asottile/_build/latest?definitionId=22&branchName=master
              Build      Status.TP      Azure      Pipelines     Coverage     (Test     coverage)
              https://dev.azure.com/asottile/asottile/_build/latest?definitionId=22&branchName=master
              Coverage Status.TP PyPI https://pypi.org/pypi/libsass/ PyPI.TP Changelog Changelog

INDICES AND TABLES

       • Index

       • Module Index

       • Search Page

AUTHOR

       Hong Minhee

COPYRIGHT

       2022, Hong Minhee