Metadata-Version: 2.1
Name: Flask-Minify
Version: 0.27
Summary: Flask extension to minify html, css, js and less.
Home-page: https://github.com/mrf345/flask_minify/
Author: Mohamed Feddad
Author-email: mrf345@gmail.com
License: MIT
Download-URL: https://github.com/mrf345/flask_minify/archive/0.27.tar.gz
Description: <h1 align='center'> flask_minify </h1>
        <p align='center'>
        <a href='https://travis-ci.com/mrf345/flask_minify'>
          <img src='https://travis-ci.com/mrf345/flask_minify.svg?branch=master'>
        </a>
        <img src='https://img.shields.io/github/v/tag/mrf345/flask_minify' alt='Latest Release' />
        <br />
        <img src='https://img.shields.io/pypi/pyversions/flask_minify' alt='Supported versions' />
        <br />
        <a href='https://coveralls.io/github/mrf345/flask_minify?branch=master'>
          <img src='https://coveralls.io/repos/github/mrf345/flask_minify/badge.svg?branch=master' alt='Coverage Status' />
        </a>
        <img src='https://img.shields.io/badge/code%20style-pep8-orange.svg' alt='Code Style' />
        <img src='https://img.shields.io/pypi/dm/flask_minify' alt='Number of downloads' />
        </p>
        <h3 align='center'>A Flask extension to parse request's response and minify html, javascript, css and less.</h3>
        
        ## Install:
        #### - With pip
        > - `pip install Flask-Minify` <br />
        
        #### - From the source:
        > - `git clone https://github.com/mrf345/flask_minify.git`<br />
        > - `cd flask_minify` <br />
        > - `python setup.py install`
        
        ## Setup:
        > With this setup the extension will minify every HTML request, unless it's explicitly bypassed.
        ```python
        from flask import Flask
        from flask_minify import minify
        
        app = Flask(__name__)
        minify(app=app, html=True, js=True, cssless=True)
        ```
        
        #### - Using a decorator instead:
        > You can set the extension to be passive so it will minify only the decorated routes.
        
        ```python
        from flask import Flask
        from flask_minify import minify, decorators
        
        app = Flask(__name__)
        minify(app=app, passive=True)
        
        @app.route('/')
        @decorators.minify(html=True, js=True, cssless=True)
        def example():
          return '<h1>Example...</h1>'
        ```
        
        ## Options:
        ```python
        def __init__(
                self, app=None, html=True, js=True, cssless=True,
                fail_safe=True, bypass=[], bypass_caching=[], caching_limit=2,
                passive=False, static=True, script_types=[]
            ):
                ''' Extension to minify flask response for html, javascript, css and less.
        
                Parameters
                ----------
                app: Flask.app
                    Flask app instance to be passed.
                js: bool
                    To minify the js output.
                cssless: bool
                    To minify spaces in css.
                fail_safe: bool
                    to avoid raising error while minifying.
                bypass: list
                    list of endpoints to bypass minifying for. (Regex)
                bypass_caching: list
                    list of endpoints to bypass caching for. (Regex)
                caching_limit: int
                    to limit the number of minified response variations.
                passive: bool
                    to disable active minifying.
                static: bool
                    to enable minifying static files css, less and js.
                script_types: list
                    list of script types to limit js minification to.
        
                Notes
                -----
                if `caching_limit` is set to 0, we'll not cache any endpoint responses,
                so if you want to disable caching just do that.
        
                `endpoint` is the name of the function decorated with the
                `@app.route()` so in the following example the endpoint will be `root`:
                    @app.route('/root/<id>')
                    def root(id):
                        return id
        
                when using a `Blueprint` the decorated endpoint will be suffixed with
                the blueprint name; `Blueprint('blueprint_name')` so here the endpoint
                will be `blueprint_name.root`.
        
                `bypass` and `bypass_caching` can handle regex patterns so if you want
                to bypass all routes on a certain blueprint you can just pass
                the pattern as such:
                    minify(app, bypass=['blueprint_name.*'])
        
                when using `script_types` include '' (empty string) in the list to
                include script blocks which are missing the type attribute.
                '''
        ```
        
        ## Development:
        - **Run Tests:** `pytest`
        - **Run style checks:** `flake8`
        
Keywords: flask,extension,minifer,htmlmin,lesscpy,jsmin,html,js,less,css
Platform: any
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Environment :: Web Environment
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Description-Content-Type: text/markdown
