# encoding: utf-8

import os

import sys

import re

import json

import csv

from contextlib import contextmanager

from functools import cmp_to_key

from collections import OrderedDict, defaultdict

from os.path import abspath, dirname, exists, join, splitext

from random import choice, shuffle

from Foundation import NSAutoreleasePool

from AppKit import NSBundle

from plotdevice import DeviceError

from .readers import read, XMLParser, Element

__all__ = ('grid', 'random', 'shuffled', 'choice', 'ordered', 'order', 'files', 'read', 'autotext', '_copy_attr', '_copy_attrs', 'odict', 'ddict', 'adict')

### Utilities ###

def grid(cols, rows, colSize=1, rowSize=1, shuffled=False):

"""Returns an iterator that contains coordinate tuples.

The grid can be used to quickly create grid-like structures. A common way to use them is:

for x, y in grid(10,10,12,12):

rect(x,y, 10,10)

"""

# Prefer using generators.

rowRange = range(int(rows))

colRange = range(int(cols))

# Shuffled needs a real list, though.

if (shuffled):

rowRange = list(rowRange)

colRange = list(colRange)

shuffle(rowRange)

shuffle(colRange)

for y in rowRange:

for x in colRange:

yield (x*colSize,y*rowSize)

def random(v1=None, v2=None, mean=None, sd=None):

"""Returns a random value.

This function does a lot of things depending on the parameters:

- If one or more floats is given, the random value will be a float.

- If all values are ints, the random value will be an integer.

- If one value is given, random returns a value from 0 to the given value.

This value is not inclusive.

- If two values are given, random returns a value between the two; if two

integers are given, the two boundaries are inclusive.

"""

import random

if v1 != None and v2 == None: # One value means 0 -> v1

if isinstance(v1, float):

return random.random() * v1

else:

return int(random.random() * v1)

elif v1 != None and v2 != None: # v1 -> v2

if isinstance(v1, float) or isinstance(v2, float):

start = min(v1, v2)

end = max(v1, v2)

return start + random.random() * (end-start)

else:

start = min(v1, v2)

end = max(v1, v2) + 1

return int(start + random.random() * (end-start))

elif mean != None and sd!= None:

return random.normalvariate(mean, sd)

else: # No values means 0.0 -> 1.0

return random.random()

def files(path="*", case=True):

"""Returns a list of files.

You can use wildcards to specify which files to pick, e.g.

f = files('~/Pictures/*.jpg')

For a case insensitive search, call files() with case=False

"""

from .iglob import iglob

# if type(path)==unicode:

# path.encode('utf-8')

path = os.path.expanduser(path)

return list(iglob(path, case=case))

def autotext(sourceFile):

from plotdevice.util.kgp import KantGenerator

k = KantGenerator(sourceFile)

return k.output()

### Permutation sugar ###

def _as_sequence(seq):

if not hasattr(seq, '__getitem__'):

badtype = 'ordered, shuffled, and friends only work for strings, tuples and lists (not %s)' % type(seq)

raise DeviceError(badtype)

return list(seq)

def _as_before(orig, lst):

return "".join(lst) if isinstance(orig, str) else list(lst)

def _key(seq, names):

# treat objects without a given key and objects with the key set to None equivalently

MISSING = None

# look for dict items by default

getter = lambda obj: tuple(obj.get(n, MISSING) for n in names)

# walk through the objects and see if any of them lacks the dict fields but has attrs

for obj in seq:

try:

if any(n in obj for n in names):

break # dict fields exist so use the itemgetter

except TypeError:

# for non-dict objects like namedtuples and dataclasses use an attrgetter

if any(hasattr(obj, n) for n in names):

getter = lambda obj: tuple(getattr(obj, n, MISSING) for n in names)

def compare(a, b):

default = 0

try:

a = getter(a)

b = getter(b)

if a > b: return 1

if a < b: return -1

except TypeError:

for aa, bb in zip(a, b):

if aa is MISSING and bb is MISSING: return default

if aa is MISSING: return default or 1

if bb is MISSING: return default or -1

if aa > bb: default = 1

if aa < bb: default = -1

return default

return cmp_to_key(compare)

def order(seq, *names, **kwargs):

lst = _as_sequence(seq)

if not names or not seq:

reordered = [(it,idx) for idx,it in enumerate(lst)]

else:

key = _key(lst, names)

reordered = [(key(it), idx) for idx,it in enumerate(lst)]

reordered.sort(**kwargs)

return [it[1] for it in reordered]

def ordered(seq, *names, **kwargs):

"""Return a sorted copy of a list or tuple, optionally using a common item or

attr name of the elements within the sequence.

If included, *names should be one or more strings indicating which `fields` of

the sequence elements should be used in comparing their equality. If more than

one name is specified, the second field will be used to break `ties' based on

the first.

The return value will be ordered in an ascending fashion, but can be flipped

using the reverse=True keyword argument."""

lst = _as_sequence(seq)

if kwargs.get('perm') and lst:

return _as_before(seq, [lst[idx] for idx in kwargs['perm']])

if not names or not lst:

return _as_before(seq, sorted(lst, **kwargs))

return _as_before(seq, sorted(lst, key=_key(lst, names), **kwargs))

def shuffled(seq):

"""Returns a random permutation of a list or tuple (without modifying the original)"""

lst = _as_sequence(seq)

shuffle(lst)

return _as_before(seq, lst)

### deepcopy helpers ###

def _copy_attr(v):

if v is None:

return None

elif hasattr(v, "copy"):

return v.copy()

elif isinstance(v, tuple):

if hasattr(v, '_fields'):

return v._replace() # don't demote namedtuples to tuples

return tuple(v)

elif isinstance(v, list):

return list(v)

elif isinstance(v, (int, str, float, bool)):

return v

else:

raise DeviceError("Don't know how to copy '%s'." % v)

def _copy_attrs(source, target, attrs):

for attr in attrs:

try:

setattr(target, attr, _copy_attr(getattr(source, attr)))

except AttributeError as e:

print("missing attr: %r"% attr, hasattr(source, attr), hasattr(target, attr))

raise e

### tuple/list de-nester ###

def _flatten(seq):

return sum( ([x] if not isinstance(x, (list,tuple)) else list(x) for x in seq), [] )

### repr decorator (tidies numbers) ###

def trim_zeroes(func):

return lambda slf: re.sub(r'\.?0+(?=[,\)\]])', '', func(slf))

### Dimension-aware number detector (replacement for isintance) ###

def numlike(obj):

return hasattr(obj, '__int__') or hasattr(obj, '__float__')

### give ordered- and default-dict a nicer repr ###

class BetterRepr(object):

def __repr__(self, indent=2):

result = '%s{'%self.__class__.__name__

for k,v in self.iteritems():

if isinstance(v, BetterRepr):

vStr = v.__repr__(indent + 2)

else:

vStr = v.__repr__()

result += "\n" + ' '*indent + k.__repr__() + ': ' + vStr

if not result.endswith('{'):

result += "\n"

result += '}'

return result

class odict(BetterRepr,OrderedDict):

"""Dictionary that remembers insertion order

Normal dict objects return keys in an arbitrary order. An odict will return them in

the order you add them. To initialize an odict and not lose the ordering in the process,

avoid using keyword arguments and instead pass a list of (key,val) tuples:

odict([ ('foo',12), ('bar',14), ('baz', 33) ])

or as part of a generator expression:

odict( (k,other[k]) for k in sorted(other.keys()) )

"""

pass

class ddict(BetterRepr,defaultdict):

"""Dictionary with default factory

Any time you access a key that was previously undefined, the factory function

is called and a default value is inserted in the dictionary. e.g.,

normal_dict = {}

normal_dict['foo'].append(42) # raises a KeyError

lst_dict = ddict(list)

lst_dict['foo'].append(42) # sets 'foo' to [42]

num_dict = ddict(int)

print num_dict['bar'] # prints '0'

num_dict['baz'] += 2 # increments 'baz' from 0 to 2

"""

pass

### the not very pythonic but often convenient dot-notation dict ###

class adict(BetterRepr, dict):

"""A dictionary object whose items may also be accessed with dot notation.

Items can be assigned using dot notation even if a dictionary method of the

same name exists. Subsequently, dot notation will still reference the method,

but the assigned value can be read out using traditional `d["name"]` syntax.

"""

def __init__(self, *args, **kw):

super(adict, self).__init__(*args, **kw)

self.__initialised = True

def __getattr__(self, key):

try:

return self[key]

except KeyError as k:

raise AttributeError(k)

def __setattr__(self, key, value):

# this test allows attributes to be set in the __init__ method

if '_adict__initialised' not in self.__dict__:

return dict.__setattr__(self, key, value)

self[key] = value

def __delattr__(self, key):

try:

del self[key]

except KeyError as k:

raise AttributeError(k)

### autorelease pool manager ###

@contextmanager

def autorelease():

pool = NSAutoreleasePool.alloc().init()

yield

del pool

### module data dir ###

def rsrc_path(resource=None):

"""Return absolute path of the rsrc directory (or a file within it)"""

mod_root = abspath(dirname(dirname(__file__)))

app_root = NSBundle.mainBundle().bundlePath()

mod_rsrc = join(mod_root, 'rsrc')

app_rsrc = join(app_root, 'Contents/Resources')

src_rsrc = join(mod_root, '../app/Resources')

for rsrc_root in (mod_rsrc, app_rsrc, src_rsrc):

if exists("%s/colors.json" % rsrc_root): # check for a known rsrc file

break

else:

raise RuntimeError("Couldn't locate resources directory.")

if resource:

return join(rsrc_root, resource)

return rsrc_root