"""Checks if file exists. Returns {} if something fails."""

data = {}

if os.path.exists(filename):

lock.acquire()

with open(filename, "r") as f:

try:

data = json.load(f)

if not isinstance(data, dict):

data = {}

except:

data = {} # TODO: issue a warning and bubble it up

lock.release()

if args:

d = dict()

for key in args:

if key in data:

d[key] = data[key]

return d

# TODO: replace with below if we drop Python 2.6 compatibility

# return {key: data[key] for key in args if key in data}

"""Save json to file. Error if path DNE, not a dict, or invalid json."""

if isinstance(json_dict, dict):

# this will raise a TypeError if something goes wrong

json_string = json.dumps(json_dict, indent=4)

lock.acquire()

with open(filename, "w") as f:

f.write(json_string)

lock.release()

else:

"""Given a valid filename, make sure it exists (will create if DNE)."""

if not os.path.exists(filename):

head, tail = os.path.split(filename)

ensure_dir_exists(head)

with open(filename, 'w') as f:

"""Given a valid directory path, make sure it exists."""

if dir:

if not os.path.isdir(directory):

"""Remove timezone info and replace 'T' delimeter with ' ' (ws)."""

# make sure we don't send timezone info to plotly

if (iso_string.split('-')[:3] is '00:00') or\

(iso_string.split('+')[0] is '00:00'):

raise Exception("Plotly won't accept timestrings with timezone info.\n"

"All timestrings are assumed to be in UTC.")

iso_string = iso_string.replace('-00:00', '').replace('+00:00', '')

if iso_string.endswith('T00:00:00'):

return iso_string.replace('T00:00:00', '')

else:

"""

def coerce_to_strict(self, const):

"""

# before python 2.7, 'true', 'false', 'null', were include here.

if const in ('Infinity', '-Infinity', 'NaN'):

return None

else:

return const

def encode(self, o):

"""

# this will raise errors in a normal-expected way

encoded_o = super(PlotlyJSONEncoder, self).encode(o)

# now:

# 1. `loads` to switch Infinity, -Infinity, NaN to None

# 2. `dumps` again so you get 'null' instead of extended JSON

try:

new_o = json.loads(encoded_o, parse_constant=self.coerce_to_strict)

except ValueError:

# invalid separators will fail here. raise a helpful exception

raise ValueError(

"Encoding into strict JSON failed. Did you set the separators "

"valid JSON separators?"

)

else:

return json.dumps(new_o, sort_keys=self.sort_keys,

indent=self.indent,

separators=(self.item_separator,

self.key_separator))

def default(self, obj):

"""

# TODO: The ordering if these methods is *very* important. Is this OK?

encoding_methods = (

self.encode_as_plotly,

self.encode_as_sage,

self.encode_as_numpy,

self.encode_as_pandas,

self.encode_as_datetime,

self.encode_as_date,

self.encode_as_list # because some values have `tolist` do last.

)

for encoding_method in encoding_methods:

try:

return encoding_method(obj)

except NotEncodable:

pass

return json.JSONEncoder.default(self, obj)

@staticmethod

def encode_as_plotly(obj):

"""Attempt to use a builtin `to_plotly_json` method."""

try:

return obj.to_plotly_json()

except AttributeError:

raise NotEncodable

@staticmethod

def encode_as_list(obj):

"""Attempt to use `tolist` method to convert to normal Python list."""

if hasattr(obj, 'tolist'):

return obj.tolist()

else:

raise NotEncodable

@staticmethod

def encode_as_sage(obj):

"""Attempt to convert sage.all.RR to floats and sage.all.ZZ to ints"""

if not _sage_imported:

raise NotEncodable

if obj in sage.all.RR:

return float(obj)

elif obj in sage.all.ZZ:

return int(obj)

else:

raise NotEncodable

@staticmethod

def encode_as_pandas(obj):

"""Attempt to convert pandas.NaT"""

if not _pandas_imported:

raise NotEncodable

if obj is pandas.NaT:

return None

else:

raise NotEncodable

@staticmethod

def encode_as_numpy(obj):

"""Attempt to convert numpy.ma.core.masked"""

if not _numpy_imported:

raise NotEncodable

if obj is numpy.ma.core.masked:

return float('nan')

else:

raise NotEncodable

@staticmethod

def encode_as_datetime(obj):

"""Attempt to convert to utc-iso time string using datetime methods."""

# first we need to get this into utc

try:

obj = obj.astimezone(pytz.utc)

except ValueError:

# we'll get a value error if trying to convert with naive datetime

pass

except TypeError:

# pandas throws a typeerror here instead of a value error, it's OK

pass

except AttributeError:

# we'll get an attribute error if astimezone DNE

raise NotEncodable

# now we need to get a nicely formatted time string

try:

time_string = obj.isoformat()

except AttributeError:

raise NotEncodable

else:

return iso_to_plotly_time_string(time_string)

@staticmethod

def encode_as_date(obj):

"""Attempt to convert to utc-iso time string using date methods."""

try:

time_string = obj.isoformat()

except AttributeError:

raise NotEncodable

else:

if isinstance(coll, list):

for no, entry in enumerate(coll):

if isinstance(entry, (dict, list)):

coll[no] = decode_unicode(entry)

else:

if isinstance(entry, str):

try:

coll[no] = str(entry)

except UnicodeEncodeError:

pass

elif isinstance(coll, dict):

keys, vals = list(coll.keys()), list(coll.values())

for key, val in zip(keys, vals):

if isinstance(val, (dict, list)):

coll[key] = decode_unicode(val)

elif isinstance(val, str):

try:

coll[key] = str(val)

except UnicodeEncodeError:

pass

coll[str(key)] = coll.pop(key)

def _decorator(func):

if sys.version[:3] != '3.2':

if func.__doc__ is not None:

func.__doc__ = func.__doc__.format(**names)

return func

seen = set()

for item in items:

if item not in seen:

seen.add(item)

else:

return item

src_regex = re.compile(r'.+src$')

if src_regex.match(key) is not None:

return True

else: