"""A container for PlotlyDicts, inherits from standard list.

def __init__(self, *args):

super(PlotlyList, self).__init__(*args)

if args and isinstance(args[0], dict):

raise exceptions.PlotlyListEntryError(

obj=self,

index=0,

notes="Just like a `list`, `{name}` must be instantiated with "

"a *single* collection.\n"

"In other words these are OK:\n"

">>> {name}()\n"

">>> {name}([])\n"

">>> {name}([dict()])\n"

">>> {name}([dict(), dict()])\n"

"However, these don't make sense:\n"

">>> {name}(dict())\n"

">>> {name}(dict(), dict())"

"".format(name=self.__class__.__name__)

)

self.validate()

if self.__class__.__name__ == 'PlotlyList':

warnings.warn("\nThe PlotlyList class is a base class of "

"list-like graph_objs.\nIt is not meant to be a "

"user interface.")

def to_graph_objs(self, caller=True):

"""Change any nested collections to subclasses of PlotlyDict/List.

for index, entry in enumerate(self):

if isinstance(entry, PlotlyDict):

try:

entry.to_graph_objs(caller=False)

except exceptions.PlotlyGraphObjectError as err:

err.add_to_error_path(index)

err.prepare()

raise # re-raise current exception

else:

raise exceptions.PlotlyListEntryError(obj=self,

index=index,

entry=entry)

def update(self, changes, make_copies=False):

"""Update current list with changed_list, which must be iterable.

if isinstance(changes, dict):

changes = [changes]

self.to_graph_objs()

for index in range(len(self)):

try:

update = changes[index % len(changes)]

except ZeroDivisionError:

pass

else:

if make_copies:

self[index].update(copy.deepcopy(update))

else:

self[index].update(update)

def strip_style(self):

"""Strip style from the current representation.

self.to_graph_objs()

for plotly_dict in self:

plotly_dict.strip_style()

def get_data(self):

"""Returns the JSON for the plot with non-data elements stripped."""

self.to_graph_objs()

l = list()

for _plotlydict in self:

l += [_plotlydict.get_data()]

del_indicies = [index for index, item in enumerate(self)

if len(item) == 0]

del_ct = 0

for index in del_indicies:

del self[index - del_ct]

del_ct += 1

return l

def validate(self, caller=True):

"""Recursively check the validity of the entries in a PlotlyList.

if caller: # change everything to PlotlyList/Dict objects

try:

self.to_graph_objs()

except exceptions.PlotlyGraphObjectError as err:

err.prepare()

raise

for index, entry in enumerate(self):

if isinstance(entry, PlotlyDict):

try:

entry.validate(caller=False)

except exceptions.PlotlyGraphObjectError as err:

err.add_to_error_path(index)

err.prepare()

raise

else:

raise exceptions.PlotlyGraphObjectError( # TODO!!!

message=(

"uh-oh, this error shouldn't have happenend."

),

plain_message=(

"uh-oh, this error shouldn't have happenend."

),

path=[index],

)

def to_string(self, level=0, indent=4, eol='\n',

pretty=True, max_chars=80):

"""Returns a formatted string showing graph_obj constructors.

self.to_graph_objs()

if not len(self):

return "{name}()".format(name=self.__class__.__name__)

string = "{name}([{eol}{indent}".format(

name=self.__class__.__name__,

eol=eol,

indent=' ' * indent * (level + 1))

for index, entry in enumerate(self):

string += entry.to_string(level=level+1,

indent=indent,

eol=eol,

pretty=pretty,

max_chars=max_chars)

if index < len(self) - 1:

string += ",{eol}{indent}".format(

eol=eol,

indent=' ' * indent * (level + 1))

string += (

"{eol}{indent}])").format(eol=eol, indent=' ' * indent * level)

return string

def get_ordered(self, caller=True):

if caller:

try:

self.to_graph_objs(caller=False)

except exceptions.PlotlyGraphObjectError as err:

err.add_note("Could not order list because it could not be "

"converted to a valid graph object.")

err.prepare()

raise

ordered_list = []

for index, entry in enumerate(self):

ordered_list += [entry.get_ordered()]

return ordered_list

def force_clean(self, caller=True):

"""Attempts to convert to graph_objs and calls force_clean() on entries.

if caller:

self.to_graph_objs() # TODO add error handling here!

for entry in self:

entry.force_clean(caller=False)

del_indicies = [index for index, item in enumerate(self)

if len(item) == 0]

del_ct = 0

for index in del_indicies:

del self[index - del_ct]

"""A base dict class for all objects that style a figure in plotly.

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

class_name = self.__class__.__name__

for key in kwargs:

if utils.is_source_key(key):

kwargs[key] = self._assign_id_to_src(key, kwargs[key])

super(PlotlyDict, self).__init__(*args, **kwargs)

if issubclass(NAME_TO_CLASS[class_name], PlotlyTrace):

if (class_name != 'PlotlyTrace') and (class_name != 'Trace'):

self['type'] = NAME_TO_KEY[class_name]

self.validate()

if self.__class__.__name__ == 'PlotlyDict':

warnings.warn("\nThe PlotlyDict class is a base class of "

"dictionary-like graph_objs.\nIt is not meant to be "

"a user interface.")

def __setitem__(self, key, value):

if key in ('xsrc', 'ysrc'):

value = self._assign_id_to_src(key, value)

return super(PlotlyDict, self).__setitem__(key, value)

def _assign_id_to_src(self, src_name, src_value):

if isinstance(src_value, six.string_types):

src_id = src_value

else:

try:

src_id = src_value.id

except:

err = ("{0} does not have an `id` property. "

"{1} needs to be assigned to either an "

"object with an `id` (like a "

"plotly.grid_objs.Column) or a string. "

"The `id` is a unique identifier "

"assigned by the Plotly webserver "

"to this grid column.")

src_value_str = str(src_value)

err = err.format(src_name, src_value_str)

raise exceptions.InputError(err)

if src_id == '':

err = exceptions.COLUMN_NOT_YET_UPLOADED_MESSAGE

err.format(column_name=src_value.name, reference=src_name)

raise exceptions.InputError(err)

return src_id

def update(self, dict1=None, **dict2):

"""Update current dict with dict1 and then dict2.

self.to_graph_objs()

if dict1 is not None:

for key, val in list(dict1.items()):

if key in self:

if isinstance(self[key], (PlotlyDict, PlotlyList)):

self[key].update(val)

else:

self[key] = val

else:

self[key] = val

if len(dict2):

for key, val in list(dict2.items()):

if key in self:

if isinstance(self[key], (PlotlyDict, PlotlyList)):

self[key].update(val)

else:

self[key] = val

else:

self[key] = val

self.to_graph_objs()

def strip_style(self):

"""Strip style from the current representation.

self.to_graph_objs()

obj_key = NAME_TO_KEY[self.__class__.__name__]

keys = list(self.keys())

for key in keys:

if isinstance(self[key], (PlotlyDict, PlotlyList)):

self[key].strip_style()

else:

try:

if INFO[obj_key]['keymeta'][key]['key_type'] == 'style':

if isinstance(self[key], six.string_types):

del self[key]

elif not hasattr(self[key], '__iter__'):

del self[key]

except KeyError: # TODO: Update the JSON

# print("'type' not in {0} for {1}".format(obj_key, key))

pass

def get_data(self):

"""Returns the JSON for the plot with non-data elements stripped."""

self.to_graph_objs()

class_name = self.__class__.__name__

obj_key = NAME_TO_KEY[class_name]

d = dict()

for key, val in list(self.items()):

if isinstance(val, (PlotlyDict, PlotlyList)):

d[key] = val.get_data()

else:

try:

# TODO: Update the JSON

if INFO[obj_key]['keymeta'][key]['key_type'] == 'data':

d[key] = val

except KeyError:

pass

keys = list(d.keys())

for key in keys:

if isinstance(d[key], (dict, list)):

if len(d[key]) == 0:

del d[key]

if len(d) == 1:

d = list(d.values())[0]

return d

def to_graph_objs(self, caller=True):

"""Walk obj, convert dicts and lists to plotly graph objs.

info_key = NAME_TO_KEY[self.__class__.__name__]

keys = self.keys()

updated_keys = graph_objs_tools.update_keys(keys)

for k_old, k_new in zip(keys, updated_keys):

if k_old != k_new:

self[k_new] = self.pop(k_old)

warnings.warn(

"\n"

"The key, '{old}', has been depreciated, it's been "

"converted to '{new}'. You should change your code to use "

"'{new}' in the future."

"".format(old=k_old, new=k_new)

)

for key in updated_keys:

if isinstance(self[key], (PlotlyDict, PlotlyList)):

try:

self[key].to_graph_objs(caller=False)

except exceptions.PlotlyGraphObjectError as err:

err.add_to_error_path(key)

err.prepare()

raise

elif (key in INFO[info_key]['keymeta'].keys() and

'key_type' in INFO[info_key]['keymeta'][key].keys()):

if INFO[info_key]['keymeta'][key]['key_type'] == 'object':

class_name = KEY_TO_NAME[key]

obj = get_class_instance_by_name(class_name)

if isinstance(obj, PlotlyDict):

if not isinstance(self[key], dict):

try:

val_types = (

INFO[info_key]['keymeta'][key]['val_types']

)

except KeyError:

val_types = 'undocumented'

raise exceptions.PlotlyDictValueError(

obj=self,

key=key,

value=self[key],

val_types=val_types,

notes="value needs to be dictionary-like"

)

for k, v in list(self.pop(key).items()):

obj[k] = v # finish up momentarily...

else: # if not PlotlyDict, it MUST be a PlotlyList

if not isinstance(self[key], list):

try:

val_types = (

INFO[info_key]['keymeta'][key]['val_types']

)

except KeyError:

val_types = 'undocumented'

raise exceptions.PlotlyDictValueError( # TODO!!!

obj=self,

key=key,

value=self[key],

val_types=val_types,

notes="value needs to be list-like"

)

obj += self.pop(key)

try:

obj.to_graph_objs(caller=False)

except exceptions.PlotlyGraphObjectError as err:

err.add_to_error_path(key)

err.prepare()

raise

self[key] = obj # whew! made it!

def validate(self, caller=True): # TODO: validate values too?

"""Recursively check the validity of the keys in a PlotlyDict.

if caller: # change everything to 'checkable' objs

try:

self.to_graph_objs(caller=False)

except exceptions.PlotlyGraphObjectError as err:

err.prepare()

raise

obj_key = NAME_TO_KEY[self.__class__.__name__]

for key, val in list(self.items()):

if isinstance(val, (PlotlyDict, PlotlyList)):

try:

val.validate(caller=False)

except exceptions.PlotlyGraphObjectError as err:

err.add_to_error_path(key)

err.prepare()

raise

else:

if key in INFO[obj_key]['keymeta'].keys():

if 'key_type' not in INFO[obj_key]['keymeta'][key].keys():

continue # TODO: 'type' may not be documented yet!

if INFO[obj_key]['keymeta'][key]['key_type'] == 'object':

try:

val_types = (

INFO[obj_key]['keymeta'][key]['val_types'])

except KeyError:

val_types = 'undocumented'

raise exceptions.PlotlyDictValueError(

obj=self,

key=key,

value=val,

val_types=val_types

)

else:

matching_objects = [obj for obj in

INFO if key in INFO[obj]['keymeta']]

notes = ''

if len(matching_objects):

notes += "That key is valid only in these objects:\n\n"

for obj in matching_objects:

notes += "\t{0}".format(KEY_TO_NAME[obj])

try:

notes += '({0}="{1}")\n'.format(

repr(key),

INFO[obj]['keymeta'][key]['val_types'])

except KeyError:

notes += '({0}="..")\n'.format(repr(key))

notes.expandtabs()

else:

notes += ("Couldn't find uses for key: {0}\n\n"

"".format(repr(key)))

raise exceptions.PlotlyDictKeyError(obj=self,

key=key,

notes=notes)

def to_string(self, level=0, indent=4, eol='\n',

pretty=True, max_chars=80):

"""Returns a formatted string showing graph_obj constructors.

self.to_graph_objs() # todo, consider catching and re-raising?

if not len(self):

return "{name}()".format(name=self.__class__.__name__)

string = "{name}(".format(name=self.__class__.__name__)

index = 0

obj_key = NAME_TO_KEY[self.__class__.__name__]

# This sets the order of the keys! nice.

for key in INFO[obj_key]['keymeta']:

if key in self:

index += 1

string += "{eol}{indent}{key}=".format(

eol=eol,

indent=' ' * indent * (level+1),

key=key)

try:

string += self[key].to_string(level=level+1,

indent=indent,

eol=eol,

pretty=pretty,

max_chars=max_chars)

except AttributeError:

if pretty: # curtail representation if too many chars

max_len = (max_chars -

indent*(level + 1) -

len(key + "=") -

len(eol))

if index < len(self):

max_len -= len(',') # remember the comma!

if isinstance(self[key], list):

s = "[]"

for iii, entry in enumerate(self[key], 1):

if iii < len(self[key]):

s_sub = graph_objs_tools.curtail_val_repr(

entry,

max_chars=max_len - len(s),

add_delim=True

)

else:

s_sub = graph_objs_tools.curtail_val_repr(

entry,

max_chars=max_len - len(s),

add_delim=False

)

s = s[:-1] + s_sub + s[-1]

if len(s) == max_len:

break

string += s

else:

string += graph_objs_tools.curtail_val_repr(

self[key], max_len)

else: # they want it all!

string += repr(self[key])

if index < len(self):

string += ","

if index == len(self): # TODO: extraneous...

break

string += "{eol}{indent})".format(eol=eol, indent=' ' * indent * level)

return string

def get_ordered(self, caller=True):

if caller: # change everything to 'order-able' objs

try:

self.to_graph_objs(caller=False)

except exceptions.PlotlyGraphObjectError as err:

err.add_note("dictionary could not be ordered because it "

"could not be converted to a valid plotly graph "

"object.")

err.prepare()

raise

obj_type = NAME_TO_KEY[self.__class__.__name__]

ordered_dict = OrderedDict()

# grab keys like xaxis1, xaxis2, etc...

unordered_keys = [key for key in self

if key not in INFO[obj_type]['keymeta']]

for key in INFO[obj_type]['keymeta']:

if key in self:

if isinstance(self[key], (PlotlyDict, PlotlyList)):

ordered_dict[key] = self[key].get_ordered(caller=False)

else:

ordered_dict[key] = self[key]

for key in unordered_keys:

if isinstance(self[key], (PlotlyDict, PlotlyList)):

ordered_dict[key] = self[key].get_ordered(caller=False)

else:

ordered_dict[key] = self[key]

return ordered_dict

def force_clean(self, caller=True):

"""Attempts to convert to graph_objs and call force_clean() on values.

obj_key = NAME_TO_KEY[self.__class__.__name__]

if caller:

self.to_graph_objs(caller=False)

del_keys = [key for key in self

if str(key) not in INFO[obj_key]['keymeta']]

for key in del_keys:

del self[key]

keys = list(self.keys())

for key in keys:

try:

self[key].force_clean(caller=False) # TODO: add error handling

except AttributeError:

pass

if isinstance(self[key], (dict, list)):

if len(self[key]) == 0:

del self[key] # clears empty collections!

elif self[key] is None:

"""A general data class for plotly.

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

super(PlotlyTrace, self).__init__(*args, **kwargs)

if self.__class__.__name__ == 'PlotlyTrace':

warnings.warn("\nThe PlotlyTrace class is a base class of "

"dictionary-like plot types.\nIt is not meant to be "

"a user interface.")

def to_string(self, level=0, indent=4, eol='\n',

pretty=True, max_chars=80):

"""Returns a formatted string showing graph_obj constructors.

self.to_graph_objs()

if self.__class__.__name__ != "Trace":

trace_type = self.pop('type')

string = super(PlotlyTrace, self).to_string(level=level,

indent=indent,

eol=eol,

pretty=pretty,

max_chars=max_chars)

self['type'] = trace_type

else:

string = super(PlotlyTrace, self).to_string(level=level,

indent=indent,

eol=eol,

pretty=pretty,

max_chars=max_chars)

"""A general data class for plotly. Never validated...

def to_graph_objs(self, caller=True): # TODO TODO TODO! check logic!

"""Change any nested collections to subclasses of PlotlyDict/List.

for index, entry in enumerate(self):

if isinstance(entry, PlotlyDict):

self[index] = get_class_instance_by_name(

entry.__class__.__name__, entry)

elif isinstance(entry, dict):

if 'type' not in entry: # assume 'scatter' if not given

entry['type'] = 'scatter'

try:

obj_name = KEY_TO_NAME[entry['type']]

except KeyError:

raise exceptions.PlotlyDataTypeError(

obj=self,

index=index

)

obj = get_class_instance_by_name(obj_name)

for k, v in list(entry.items()):

obj[k] = v

self[index] = obj

if not isinstance(self[index], PlotlyTrace): # Trace ONLY!!!

raise exceptions.PlotlyListEntryError(

obj=self,

index=index,

notes=(

"The entry could not be converted into a PlotlyTrace "

"object (e.g., Scatter, Heatmap, Bar, etc)."

),

)

super(Data, self).to_graph_objs(caller=caller)

Data.to_graph_objs = to_graph_objs # override method!

def to_graph_objs(self, caller=True):

"""Change any nested collections to subclasses of PlotlyDict/List.

for index, entry in enumerate(self):

if isinstance(entry, (PlotlyDict, PlotlyList)):

if not isinstance(entry, NAME_TO_CLASS['Annotation']):

raise exceptions.PlotlyListEntryError(

obj=self,

index=index,

notes="The entry could not be converted into an "

"Annotation object because it was already a "

"different kind of graph object.",

)

elif isinstance(entry, dict):

obj = get_class_instance_by_name('Annotation')

for k, v in list(entry.items()):

obj[k] = v

self[index] = obj

else:

raise exceptions.PlotlyListEntryError(

obj=self,

index=index,

notes=(

"The entry could not be converted into an Annotation "

"object because it was not a dictionary."

),

)

super(Annotations, self).to_graph_objs(caller=caller)

Annotations.to_graph_objs = to_graph_objs # override method!

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

if len(args):

if ('data' not in kwargs) and ('data' not in args[0]):

kwargs['data'] = Data()

if ('layout' not in kwargs) and ('layout' not in args[0]):

kwargs['layout'] = Layout()

else:

if 'data' not in kwargs:

kwargs['data'] = Data()

if 'layout' not in kwargs:

kwargs['layout'] = Layout()

super(Figure, self).__init__(*args, **kwargs)

Figure.__init__ = __init__ # override method!

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

super(Layout, self).__init__(*args, **kwargs)

def to_graph_objs(self, caller=True):

"""Walk obj, convert dicts and lists to plotly graph objs.

keys = list(self.keys())

for key in keys:

if key[:5] in ['xaxis', 'yaxis']: # allows appended integers!

try:

axis_int = int(key[5:]) # may raise ValueError

if axis_int == 0:

continue # xaxis0 and yaxis0 are not valid keys...

except ValueError:

continue # not an XAxis or YAxis object after all

if isinstance(self[key], dict):

if key[:5] == 'xaxis':

obj = get_class_instance_by_name('XAxis')

else:

obj = get_class_instance_by_name('YAxis')

for k, v in list(self.pop(key).items()):

obj[k] = v

self[key] = obj # call to super will call 'to_graph_objs'

super(Layout, self).to_graph_objs(caller=caller)

def to_string(self, level=0, indent=4, eol='\n',

pretty=True, max_chars=80):

"""Returns a formatted string showing graph_obj constructors.

# TODO: can't call super

self.to_graph_objs()

if not len(self):

return "{name}()".format(name=self.__class__.__name__)

string = "{name}(".format(name=self.__class__.__name__)

index = 0

obj_key = NAME_TO_KEY[self.__class__.__name__]

for key in INFO[obj_key]['keymeta']:

if key in self:

string += "{eol}{indent}{key}=".format(

eol=eol,

indent=' ' * indent * (level+1),

key=key)

try:

string += self[key].to_string(level=level+1,

indent=indent,

eol=eol,

pretty=pretty,

max_chars=max_chars)

except AttributeError:

if pretty: # curtail representation if too many chars

max_len = (max_chars -

indent*(level + 1) -

len(key + "=") -

len(eol))

if index < len(self):