RBN-Reservoir-Code/utils.py at master · aleksanb/RBN-Reservoir-Code · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
import pickle
import logging
import os
import subprocess
import glob
from datetime import datetime
import numpy as np

logger = logging.getLogger()


def select(field, collection):
    return [item[field] for item in collection]


def fst(t):
    return t[0]


def snd(t):
    return t[1]


def lst(t):
    return t[-1]


def user_denies(message):
    return raw_input(message + ' [Y/n] ').strip() == 'n'


def user_confirms(message):
    return raw_input(message + ' [N/y] ').strip() == 'y'


def deviation_stats(description, numbers):
    logger.info('Stats for {} ({} items)'.format(description, len(numbers)))
    logger.info(
        'Largest: {}, Smallest: {}, Mean: {}, Std: {}'
        .format(max(numbers), min(numbers), np.mean(numbers), np.std(numbers)))


def default_input(name, default):
    query = raw_input('{} (default: {}): '.format(name, default))

    if query:
        if type(default) is int:
            return int(query)
        elif type(default) is str:
            return str(query)
        elif type(default) is float:
            return float(query)

    return default


def get_working_dir(prefix='pickle_dumps'):
    directory = default_input('Set working directory', '')

    working_dir = '{}/{}/'.format(prefix, directory)
    if not os.path.exists(working_dir):
        if not user_denies('Directory {} does not exist. Create it?'
                           .format(working_dir)):
            os.makedirs(working_dir)
            logger.info('Created folder: {}'.format(working_dir))

    return working_dir


def glob_load(pattern):
    matches = glob.glob(pattern)

    if len(matches) == 0:
        logger.warn(
            'No files matching pattern {}!'.format(pattern))
        return None

    results = [(pickle.load(open(match, 'r')), match)
               for match in matches]

    logger.info('Loaded {} pickle(s): {}'.format(
        len(matches),
        matches))

    return results


def load(query, folder=''):
    name = folder + raw_input(
        '{} (from {}) '.format(query, folder))
    obj = pickle.load(open(name, 'r'))

    logger.info('Loaded pickle: {}'.format(name))

    return obj


def dump(obj, name, folder=''):
    date = datetime.now().strftime('%Y-%m-%d-%H:%M:%S')
    name = '{}{}-{}'.format(folder, date, name)

    pickle.dump(obj, open(name, 'w'))
    logger.info('Created pickle: {}'.format(name))


def git(*args):
    gitproc = subprocess.Popen(['git'] + list(args), stdout=subprocess.PIPE)
    stdout, _ = gitproc.communicate()
    return stdout.strip()


def log_git_info():
    logger.info('git revision: %s' % git('rev-parse', 'HEAD'))
    if git('diff'):
        logger.warn('Git working directory not clean!')