qual-city

#! /usr/bin/env python3
# -*- coding: <utf-8> -*-

"""qualcity.

Usage:
    qual-city (-h | --help)
    qual-city pipeline <pipline_conf> [logger <log_conf>] [(-v | --verbose)]

Options:
    -h --help           Show this screen.
    -v --verbose        Verbose mode

"""

import time
import os

import docopt

import operator

import yaml

import logging
import logging.config

import matplotlib.pyplot as plt

import qualcity.features
import qualcity.labels
import qualcity.learning
import qualcity.utils
import qualcity.config


logger = logging.getLogger('qualcity')

def config_logger(arguments):
    if not arguments['logger']:
        logging.config.dictConfig(qualcity.config.logger_default)
        logger.info('Default logger chosen.')
    else:
        with open(arguments['<log_conf>'], mode='r') as conf:
            configuration = yaml.load(conf)

        configuration['handlers']['file']['filename'] = (
            'qualcity-' + time.ctime() + '.log'
        )
        configuration['loggers']['qualcity']['level'] = (
            'DEBUG' if arguments['--verbose'] else 'INFO'
        )
        logging.config.dictConfig(
            configuration
        )
        logger.info('Loaded logger from: ' + arguments['<log_conf>'])
        logger.debug(yaml.dump(configuration))


def prepare_cache(cache_file):
    if not os.path.isdir(cache_file):
        os.mkdir(cache_file)
    if not os.path.isdir(os.path.join(cache_file, 'predictions')):
        os.mkdir(os.path.join(cache_file, 'predictions'))
    if not os.path.isdir(os.path.join(cache_file, 'classifiers')):
        os.mkdir(os.path.join(cache_file, 'classifiers'))
    if not os.path.isdir(os.path.join(cache_file, 'features')):
        os.mkdir(os.path.join(cache_file, 'features'))
    if not os.path.isdir(os.path.join(cache_file, 'reports')):
        os.mkdir(os.path.join(cache_file, 'reports'))


def get_labels(hierarchical, depth, LoD, threshold, labels_path, filetype):
    logger.info('Getting Labels ...')
    return [
        (building, label)
        for building, label in sorted(
            qualcity.labels.labels_map(
                labels_path,
                hierarchical,
                depth,
                LoD,
                threshold,
                filetype
            ).items(),
            key=operator.itemgetter(0)
        )
    ]


def format_labels(hierarchical, depth, LoD, threshold, labels_path, filetype):
    logger.info('Formatting labels')
    labels = get_labels(
        hierarchical,
        depth,
        LoD,
        threshold,
        labels_path,
        filetype
    )
    if depth > 0:
        labels = [
            (building, label)
            for building, label in labels
            if label != 'Unqualifiable'
        ]
    return zip(*labels)


def build_reductor(algorithm, **parameters):
    logger.info('Building a dimension reductor...')

    if parameters['n_components'] > 3:
        logger.error('Cannot visualize more than three dimensions!')
        raise ValueError
    elif parameters['n_components'] < 2:
        logger.error('Cannot visualize less than two dimensions!')
        raise ValueError

    return qualcity.utils.resolve(algorithm)(
        **parameters
    )


def visualize(features, labels, label_names, **visualization_args):
    logger.info('Feature space visualization.')
    qualcity.features.visualize_features(
        features,
        labels,
        label_names,
        build_reductor(
            visualization_args['dimension_reduction']['algorithm'],
            **visualization_args['dimension_reduction']['parameters']
        ),
        visualization_args['dimension_reduction']['parameters']['n_components'],
        **visualization_args['style']
    )
    logger.info('Visualization process ended.')


def process(form, features, labels, buildings, label_names, cache_file, cache_config, **process_args):
    logger.info('Processing features...')
    if 'visualization' in process_args.keys():
        if form == 'vector':
            visualize(
                features,
                labels,
                label_names,
                **process_args['visualization']
            )
        else:
            raise RuntimeError('Impossible to visualize features in {} form'.format(form))

    qualcity.learning.classify(
        form,
        features,
        qualcity.learning.fuse(form, **process_args['fusion']),
        labels,
        buildings,
        label_names,
        cache_file,
        cache_config,
        **process_args['classification']
    )
    logger.info('Succesfully classified features.')
    plt.show()


def load_pipeline_config(pip_conf):
    logger.info('Loading pipeline configuration file...')
    with open(pip_conf, mode='r') as conf:
        return yaml.load(conf)


def label_names(config, labels):
    if config['depth'] < 2:
        return tuple(set(labels))
    elif config['depth'] == 2:
        return (
            tuple(set(labels)) if config['hierarchical']
            else ['Building', 'Facet']
        )
    elif config['depth'] == 3:
        return (
            {
                'Valid': None,
                'Building': qualcity.labels.LABELS(
                    config['LoD'],
                    ['Building'],
                    drop=True
                ),
                'Facet': qualcity.labels.LABELS(
                    config['LoD'],
                    ['Facet']
                )
            } if config['hierarchical']
            else qualcity.labels.LABELS(
                config['LoD'],
                ['Building', 'Facet'],
                drop=True
            )
        )
    else:
        raise LookupError('depth cannot be > 3')


def main():
    arguments = docopt.docopt(
        __doc__,
        help=True,
        version=qualcity.config.__version__,
        options_first=False
    )

    config_logger(arguments)

    configuration = load_pipeline_config(arguments['<pipline_conf>'])
    logger.info('Pipeline loaded.')

    prepare_cache(configuration['cache'])
    logger.info('Cache prepared.')

    buildings, labels = format_labels(
        **configuration['labels']
    )
    logger.debug(
        'There are %s buildings. Buildings are: %s',
        len(buildings),
        buildings
    )
    logger.debug('Labels are: %s', labels)
    logger.info('Labels safely loaded.')

    (form, features) = qualcity.features.get_features(
        buildings,
        configuration['cache'],
        **configuration['features']
    )
    if form == 'kernel':
        features_config, features = zip(*features)
        print(features_config)
        logger.info('Feature configuration:')
        logger.info(features_config)
    logger.debug(features)
    logger.info('Features safely loaded.')

    process(
        form,
        features,
        labels,
        buildings,
        label_names(
            configuration['labels'],
            labels
        ),
        configuration['cache'],
        {
            key: conf
            for (key, conf) in configuration.items()
            if key in ['labels', 'features']
        },
        **configuration['processing']
    )


if __name__ == '__main__':
    main()