site

#!/usr/bin/env python

# python 3 stdlib
from datetime import date, datetime
from glob import glob
from itertools import groupby
from unicodedata import normalize
import codecs
import locale
import os
import re
import shutil


# see CONTRIBUTING re dependencies
from argh import ArghParser, CommandError
from flask import Flask, render_template, abort
from flask_frozen import Freezer
from flask_flatpages import FlatPages
from flaskext.markdown import Markdown
from flask_assets import Environment as AssetManager
from PIL import Image, ImageOps
from werkzeug.routing import BaseConverter

from meta_compat import MetaCompat

# Configuration
DEBUG = False
BASE_URL = 'http://www.madmode.com/'
ASSETS_DEBUG = DEBUG
FLATPAGES_AUTO_RELOAD = True
FLATPAGES_EXTENSION = '.md'
FLATPAGES_ROOT = 'pages'
FLATPAGES_MARKDOWN_EXTENSIONS = ['markdown.extensions.fenced_code']

# App configuration
FEED_MAX_LINKS = 25
SECTION_MAX_LINKS = 12


class FlaskE(Flask):
    def handle_user_exception(self, e):
        import traceback
        print(traceback.format_exc(e))
        import pdb; pdb.set_trace()  # noqa


# app = FlaskE(__name__)
app = Flask(__name__)
app.config.from_object(__name__)
pages = MetaCompat(app)
freezer = Freezer(app)
markdown_manager = Markdown(app)
asset_manager = AssetManager(app)


###############################################################################
# Model helpers

def get_pages(pages, offset=None, limit=None, tag=None, year=None, month=None):
    """ Retrieves pages matching passec criterias.
    """
    articles = [p for p in pages if p.meta.get('date')]
    # filter unpublished article
    if not app.debug:
        articles = [p for p in articles if p.meta.get('published') is True]
    if tag:
        articles = [p for p in articles if tag in p.meta.get('tags', ())]
    # filter year, month
    if year:
        articles = [p for p in articles if p.meta.get('date').year == year]
    if month:
        articles = [p for p in articles if p.meta.get('date').month == month]
    # sort by date
    articles = sorted(articles, reverse=True, key=lambda p: p.meta.get(
        'date', date.today()))
    # assign prev/next page in serie
    articles = sorted(articles, key=lambda p: p.meta.get('date'))
    articles = list(reversed(articles))
    for i, article in enumerate(articles):
        if i != 0:
            article.prev = articles[i - 1]
        if i != len(articles) - 1:
            article.next = articles[i + 1]
    # offset and limit
    if offset and limit:
        return articles[offset:limit]
    elif limit:
        return articles[:limit]
    elif offset:
        return articles[offset:]
    else:
        return articles


def tag_counts(pages):
    all_tags = [tag for pg in pages
                for tag in pg.meta.get('tags', ())]
    count_tags = [(tag, len(list(tag_group)))
                  for tag, tag_group in groupby(sorted(all_tags))]
    return sorted(count_tags, key=lambda x: x[0].lower())


def get_years(pages):
    years = sorted(set([page.meta.get('date').year for page in pages]))
    years.reverse()
    return years


def resize_image(path, box, out=None, fit=True, quality=75):
    """ Downsample an image.

        @param path:    string - path to the original image
        @param box:     tuple(x, y) - the bounding box of the result image
        @param out:     file-like-object - save the image into
                        the output stream
        @param fit:     boolean - crop the image to fill the box
        @param quality: int - JPEG quality
    """
    img = Image.open(path)
    if fit:
        img = ImageOps.fit(img, box, Image.ANTIALIAS)
    else:
        img.thumbnail(box, Image.ANTIALIAS)
    if not out:
        out = os.path.splitext(path)[0] + ".tn.jpg"
    img.save(out, "JPEG", quality=quality)


def slugify(text, delim=u'-'):
    """Generates an slightly worse ASCII-only slug."""
    _punct_re = re.compile(r'[\t !"#$%&\'()*\-/<=>?@\[\\\]^_`{|},.]+')
    result = []
    for word in _punct_re.split(text.lower()):
        word = normalize('NFKD', word).encode('ascii', 'ignore')
        if word:
            result.append(word)
    return unicode(delim.join(result))


###############################################################################
# Filters

@app.template_filter()
def to_rfc2822(dt):
    if not dt:
        return
    current_locale = locale.getlocale(locale.LC_TIME)
    locale.setlocale(locale.LC_TIME, "en_US.utf8")
    formatted = dt.strftime("%a, %d %b %Y %H:%M:%S +0000")
    locale.setlocale(locale.LC_TIME, current_locale)
    return formatted


###############################################################################
# Context processors

@app.context_processor
def inject_ga():
    return dict(BASE_URL=BASE_URL)


###############################################################################
# url_map converters


class MonthConverter(BaseConverter):
    def to_python(self, numeral):
        return int(numeral)

    def to_url(self, n):
        return '%02d' % n


app.url_map.converters['month'] = MonthConverter

###############################################################################
# Routes


@app.route('/contact/')
def contact():
    return render_template('contact.html')


@app.route('/feeds/posts/default')
def feed():
    articles = get_pages(pages, limit=FEED_MAX_LINKS)
    now = datetime.now()
    # {'Content-Type': 'text/css; charset=utf-8'}
    txt = render_template('base.rss', pages=articles, build_date=now)
    return txt, 200, {'Content-Type': 'application/rss+xml'}


@app.route('/sitemap.xml')
def sitemap():
    today = date.today()
    recently = date(year=today.year, month=today.month, day=1)
    # {'Content-Type': 'text/css; charset=utf-8'}
    txt = render_template('sitemap.xml', pages=get_pages(pages),
                           today=today, recently=recently)
    return txt, 200, {'Content-Type': 'application/xml'}


@app.route('/')
def index():
    articles = pages
    if not app.debug:
        articles = [p for p in articles if p.meta.get('published') is True]

    return render_template('index.html',
                           posts=get_pages(pages, limit=5),
                           years=get_years(get_pages(articles)),
                           tag_counts=tag_counts(articles))


@app.route('/<path:path>.html')
def page(path):
    page = pages.get_or_404(path)
    # allow preview of unpublished stuff in DEBUG mode
    if not app.debug and not page.meta.get('published', False):
        abort(404)
    template = page.meta.get('template', 'code/page.html')
    return render_template(template, page=page)


@app.route('/search/label/<string:tag>/')
def search_tag(tag):
    template = 'archives.html'
    articles = get_pages(pages, tag=tag)
    return render_template(template, pages=articles, tag=tag)


@app.route('/<int:year>/')
def archives_year(year):
    template = 'archives.html'
    years = get_years(get_pages(pages))
    articles = get_pages(pages, year=year)
    months = sorted(set([p.meta.get('date').month for p in articles]))
    return render_template(template, pages=articles,
                           years=years, months=reversed(months), year=year)


@app.route('/<int:year>_<month:month>_01_archive.html')
def archives_year_month(year, month):
    template = 'archives.html'
    years = get_years(get_pages(pages))
    articles = get_pages(pages, year=year, month=month)
    return render_template(template, pages=articles, years=years, year=year)


@app.route('/403.html')
def error403():
    return render_template('403.html')


@app.route('/404.html')
def error404():
    return render_template('404.html')


@app.route('/500.html')
def error500():
    return render_template('500.html')


@app.errorhandler(404)
def page_not_found(error):
    return render_template('404.html'), 404


###############################################################################
# Commands

def build(debug=DEBUG):
    """ Builds this site.
    """
    print("Building website...")
    app.debug = debug
    asset_manager.config['ASSETS_DEBUG'] = False
    freezer.freeze()
    for pat in ['*.ico', '*.txt', '*.xml']:
        for name in glob('./static/' + pat):
            shutil.copy2(name, './build/')

    shutil.rmtree('./build/.well-known', ignore_errors=True)
    shutil.copytree('./static/.well-known', './build/.well-known/')

    # KLUDGE:
    shutil.rmtree('./build/2012/cocogetblk/', ignore_errors=True)
    shutil.copytree('./pages/2012/cocogetblk/', './build/2012/cocogetblk/')
    print("Done.")


def post(title=None, filename=None):
    """ Create a new empty post.
    """
    post_date = datetime.today()
    title = unicode(title) if title else "Untitled Post"
    if not filename:
        filename = u"%s.md" % slugify(title)
    year = post_date.year
    pathargs = [str(year), filename, ]
    filepath = os.path.join(os.path.abspath(os.path.dirname(__file__)),
                            FLATPAGES_ROOT, '/'.join(pathargs))
    if os.path.exists(filepath):
        raise CommandError("File %s exists" % filepath)
    content = '\n'.join([
        u"title: %s" % title,
        u"date: %s" % post_date.strftime("%Y-%m-%d"),
        u"published: false\n\n",
    ])
    try:
        codecs.open(filepath, 'w', encoding='utf8').write(content)
        print(u'Created %s' % filepath)
    except Exception as error:
        raise CommandError(error)


def photo(path, slug):
    """ Adds a new photo.
    """
    photo_date = datetime.today()
    # check slug
    slug = slugify(unicode(slug))
    if not isinstance(slug, basestring) or not slug.strip():
        raise CommandError("Invalid slug: " + slug)
    # check that the path is valid, is an image
    if not os.path.exists(path) or not os.path.isfile(path):
        raise CommandError("Invalid path: " + path)
    # create directory for images: %year/%slug
    photo_dir = os.path.join("static", "photography", str(photo_date.year),
                             slug)
    if os.path.exists(photo_dir):
        raise CommandError("path %s already exists" % photo_dir)
    os.mkdir(photo_dir, 0o755)
    print(u'Created %s' % photo_dir)
    # copy original image to original.jpg
    original_path = os.path.join(photo_dir, "original.jpg")
    shutil.copyfile(path, original_path)
    print(u'Copied original to %s' % original_path)
    # resize the image: main.jpg and thumb.jpg
    thumb_path = os.path.join(photo_dir, "thumb.jpg")
    resize_image(original_path, (280, 280), fit=True, out=thumb_path)
    print(u'Created %s' % thumb_path)
    main_path = os.path.join(photo_dir, "main.jpg")
    resize_image(original_path, (900, 900), fit=False, out=main_path)
    print(u'Created %s' % main_path)
    # post file
    filename = slug + FLATPAGES_EXTENSION
    pathargs = ["photography", str(photo_date.year), filename, ]
    filepath = os.path.join(os.path.abspath(os.path.dirname(__file__)),
                            FLATPAGES_ROOT, '/'.join(pathargs))
    if os.path.exists(filepath):
        raise CommandError("File %s exists" % filepath)
    content = '\n'.join([
        u"title: ",
        u"date: %s" % photo_date.strftime("%Y-%m-%d"),
        u"type: photo",
        u"published: false\n\n\n",
    ])
    try:
        codecs.open(filepath, 'w', encoding='utf8').write(content)
        print(u'Created %s' % filepath)
    except Exception as error:
        raise CommandError(error)
    print('All done.')


def serve(server='127.0.0.1', port=5000, debug=DEBUG):
    """ Serves this site.
    """
    asset_manager.config['ASSETS_DEBUG'] = debug
    if debug:
        app.debug = True
    app.run(host=server, port=port, debug=debug)


if __name__ == '__main__':
    parser = ArghParser()
    parser.add_commands([build, photo, post, serve, ])
    parser.dispatch()