Ubuntu Manpage: libsass - libsass Documentation

Provided by: python3-libsass_0.20.1-3build1_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 --- Application Dispatching
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 ' conjuction.

              >>> 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.  Everytime 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 softwares 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 changes

INDICES AND TABLES

       • genindex

       • modindex

       • search

AUTHOR

       Hong Minhee

COPYRIGHT

       2021, Hong Minhee