# -*- coding: iso-8859-15 -*-

"""

My collected generic utilities (whether coded by me or others)

"""

from __future__ import absolute_import, division

import copy

import cPickle

import functools

import grp

import inspect

import itertools

import multiprocessing

import os

import re

import sys

import time

import numpy as np

try:

from pisa.utils.log import logging

except ImportError:

class Logging(object):

sys.stderr.flush()

logging = Logging()

try:

import pisa.utils.fileio as fileio

except ImportError:

pass

__all__ = ['chown_and_chmod', 'SIGMA_OR_PCT_RE', 'sigmaOrPct2ConfIntvl',

'applyParallel']

def chown_and_chmod(f, mode, uid=-1, group=-1):

raise TypeError('Unhandled type for arg `f`: %s' % type(f))

SIGMA_OR_PCT_RE = re.compile(

r'(?P<val>[0-9]+)(?P<unit>sigma|sig|pct|percent|%)'

)

def sigmaOrPct2ConfIntvl(s):

raise ValueError('Could not parse string into sigma or percent: "%s"' % s)

def sigmaOrPct2chi2(s, dof):

raise ValueError('Could not parse string into sigma or percent: "%s"' % s)

def sigma2confIntvl(s):

return stats.chi2.cdf(s**2, 1)

def pct2sigma(pct):

return np.sqrt(stats.chi2.ppf(pct, 1))

def pct2confIntvl(pct):

return sigma2confIntvl(pct2sigma(pct))

def confIntvl2chi2(ci, dof):

return stats.chi2.ppf(ci, dof)

def sigma2chi2(sigma, dof):

return sigma**2 #confIntvl2chi2(sigma2confIntvl(sigma), dof)

def pct2chi2(pct, dof):

return confIntvl2chi2(pct2confIntvl(pct), dof)

def jeffreys_interval(x_successes, n_trials, conf):

return lower_bound, upper_bound

# NOTE: See pyDOE for regular Latin hypercube sampling

#def orthogonalSample(dims, divs, subdivs, seed=1439):

# """

# dims

# Number of dimensions of parameter hypercube

#

# divs

# Number of divisions to divide each parameter into; it is guaranteed

# that each of the resulting subspaces will receive one sample

#

# N_subspaces = divs**dims

#

# subdivs

# Number of subdivisions to divide the division into (for each parameter)

#

# N_bins = (subdivs*divs)**dims

# N_samples = N_subspaces

#

# seed

# Random seed to set prior to generating the samples

# """

# np.random.seed(seed)

def trace(frame, event, arg): # pylint: disable=unused-argument

wstderr("%s, %s:%d\n" % (event, frame.f_code.co_filename, frame.f_lineno))

return trace

def my_hash(s):

import xxhash

return xxhash.xxh64(s).hexdigest()

def cmp_to_key(mycmp):

return K

def genericTester(cases, transform):

assert np.all(passed)

class DictDiffer(object):

if self.past_dict[o] == self.current_dict[o])

def expand(path):

"""Shortcut to expand user and (shell) vars in a pathname"""

return os.path.expandvars(os.path.expanduser(path))

def absPath(path):

return os.path.abspath(os.path.expandvars(os.path.expanduser(path)))

def path_components(path):

return reversed_comp[::-1]

def get_gid(group):

return grp.getgrnam(group).gr_gid

def mkdir(d, mode=0o2777, group=None, warn=True):

os.chown(fullpath, -1, gid)

def timediffstamp(dt_sec, hms_always=False, sec_decimals=3):

return sign_str + strdt

def timestamp(at=None, d=True, t=True, tz=True, utc=False, winsafe=False,

return dts

#-- Credit to http://nedbatchelder.com/blog/200712.html#e20071211T054956

# for the original code and to

# http://personal.inet.fi/cool/operator/Human%20Sort.py

# for the internationalized version below

#numeric_rex = re.compile(r'([0-9]+)')

#def numericSortFn(s):

#

#

## The code extended with suitable renamings:

#spec_dict = {'Å':'A', 'Ä':'A'}

#

#def spec_order(s):

# return ''.join([spec_dict.get(ch, ch) for ch in s])

#

#def trynum(s):

# try:

# return float(s)

# except:

# return spec_order(s)

#

#def alphanum_key(s):

# """ Turn a string into a list of string and number chunks.

# "z23a" -> ["z", 23, "a"]

# """

# return [ trynum(c) for c in re.split('([0-9]+\.?[0-9]*)', s) ]

#

#def sort_nicely(l):

# """ Sort the given list in the way that humans expect.

# """

# l.sort(key=alphanum_key)

def nsort(l):

)

#-- ... and comment by "Py User":

#def nsort_ci(l) return sorted(l, key=lambda a.lower()):zip(re.split("(\\d+)", a)[0::2], map(int, re.split("(\\d+)", a)[1::2])))

def findFiles(root, regex=None, fname=None, recurse=True, dir_sorter=nsort,

yield fullfilepath, basename, match

def wstdout(x):

sys.stdout.write(x)

sys.stdout.flush()

def wstderr(x):

sys.stderr.write(x)

sys.stderr.flush()

def memoize_volatile(obj):

return memoizer

# TODO: Make serialization method, compression, etc. optional

# TODO: Add .pkl{protocol ver} extension to pickled files (is this even a good

# idea?)

def func_memoize_persistent(diskcache_dir=None,

return decorator

# This regex matches signed, unsigned, and scientific-notation (e.g. "1e10")

# numbers.

NUMBER_RESTR = r'((?:-|\+){0,1}[0-9.]+(?:e(?:-|\+)[0-9.]+){0,1})'

NUMBER_RE = re.compile(NUMBER_RESTR, re.IGNORECASE)

# This regex

# The starting number

# Optional range, e.g., --10 (which means "to negative 10"); in my

# interpretation, the "to" number should be *INCLUDED* in the list

# If there's a range, optional stepsize, e.g., --10 (which means "to negative

# 10")

HRGROUP_RESTR = (

)

HRGROUP_RE = re.compile(HRGROUP_RESTR, re.IGNORECASE)

def num2floatOrInt(num):

return float(num)

def isint(num):

return True

def hrgroup2list(hrgroup):

return lst

WS_RE = re.compile(r'\s')

def hrlist2list(hrlst):

return lst

def hrlol2lol(hrlol):

supergroups = re.split(r'[;]+', hrlol)

return [hrlist2list(group) for group in supergroups]

# Below is adapted by me to make scientific notation work correctly from Scott

# B's adaptation to Python 2 of Rik Poggi's answer to his question:

# stackoverflow.com/questions/9847601/convert-list-of-numbers-to-string-ranges

def hrlist_formatter(start, end, step):

if step == 1:

return '{}-{}'.format(start, end)

return '{}-{}:{}'.format(start, end, step)

def list2hrlist(lst):

return ','.join(result)

def hrbool2bool(s):

raise ValueError('Could not parse input into bool: ' + s)

def two_bad_seeds(badseed1, badseed2):

return np.random.get_state()

def n_bad_seeds(*args):

return np.random.get_state()

def samplesFilename(n_dim, n_samp, rand_set_id=0, crit='m', iterations=5,