"""

if object_name in graph_reference.ARRAYS:

help_string = _list_help(object_name, path, parent_object_names)

else:

if attribute:

help_string = _dict_attribute_help(object_name, path,

parent_object_names, attribute)

else:

help_string = _dict_object_help(object_name, path,

parent_object_names)

"""See get_help()."""

items = graph_reference.ARRAYS[object_name]['items']

items_classes = [graph_reference.string_to_class_name(item)

for item in items]

lines = textwrap.wrap(repr(items_classes), width=LINE_SIZE-TAB_SIZE)

help_dict = {

'object_name': object_name,

'path_string': '[' + ']['.join(repr(k) for k in path) + ']',

'parent_object_names': parent_object_names,

'items_string': '\t' + '\n\t'.join(lines)

}

return (

"Valid items for '{object_name}' at path {path_string} under parents "

"{parent_object_names}:\n{items_string}\n".format(**help_dict)

"""See get_help()."""

attributes = graph_reference.get_valid_attributes(object_name,

parent_object_names)

lines = textwrap.wrap(repr(list(attributes)), width=LINE_SIZE-TAB_SIZE)

help_dict = {

'object_name': object_name,

'path_string': '[' + ']['.join(repr(k) for k in path) + ']',

'parent_object_names': parent_object_names,

'attributes_string': '\t' + '\n\t'.join(lines)

}

return (

"Valid attributes for '{object_name}' at path {path_string} under "

"parents {parent_object_names}:\n\n{attributes_string}\n\n"

"Run `<{object_name}-object>.help('attribute')` on any of the above.\n"

"'<{object_name}-object>' is the object at {path_string}"

.format(**help_dict)

"""

help_dict = {

'object_name': object_name,

'path_string': '[' + ']['.join(repr(k) for k in path) + ']',

'parent_object_names': parent_object_names,

'attribute': attribute

}

valid_attributes = graph_reference.get_valid_attributes(

object_name, parent_object_names

)

help_string = (

"Current path: {path_string}\n"

"Current parent object_names: {parent_object_names}\n\n")

if attribute not in valid_attributes:

help_string += "'{attribute}' is not allowed here.\n"

return help_string.format(**help_dict)

attributes_dicts = graph_reference.get_attributes_dicts(

object_name, parent_object_names

)

attribute_definitions = []

additional_definition = None

meta_keys = graph_reference.GRAPH_REFERENCE['defs']['metaKeys']

trace_names = graph_reference.TRACE_NAMES

for key, attribute_dict in attributes_dicts.items():

if attribute in attribute_dict:

if object_name in trace_names and attribute == 'type':

d = {'role': 'info'}

else:

d = {k: v for k, v in attribute_dict[attribute].items()

if k in meta_keys and not k.startswith('_')}

elif attribute in attribute_dict.get('_deprecated', {}):

deprecate_attribute_dict = attribute_dict['_deprecated'][attribute]

d = {k: v for k, v in deprecate_attribute_dict.items()

if k in meta_keys and not k.startswith('_')}

d['deprecated'] = True

else:

continue

if key == 'additional_attributes':

additional_definition = d

continue

new_definition = True

for item in attribute_definitions:

if item['definition'] == d:

item['paths'].append(key)

new_definition = False

if new_definition:

attribute_definitions.append({'paths': [key], 'definition': d})

if attribute_definitions:

help_string += ("With the current parents, '{attribute}' can be "

"used as follows:\n\n")

help_string = help_string.format(**help_dict)

for item in attribute_definitions:

valid_parents_objects_names = [

graph_reference.attribute_path_to_object_names(definition_path)

for definition_path in item['paths']

]

if len(valid_parents_objects_names) == 1:

valid_parent_objects_names = valid_parents_objects_names[0]

help_string += 'Under {}:\n\n'.format(

str(valid_parent_objects_names)

)

else:

help_string += 'Under any of:\n\t\t* {}\n\n'.format(

'\n\t\t* '.join(str(tup) for tup in valid_parents_objects_names)

)

for meta_key, val in sorted(item['definition'].items()):

help_string += '\t{}: '.format(meta_key)

if meta_key == 'description':

# TODO: https://github.com/plotly/streambed/issues/3950

if isinstance(val, list) and attribute == 'showline':

val = val[0]

lines = textwrap.wrap(val, width=LINE_SIZE)

help_string += '\n\t\t'.join(lines)

else:

help_string += '{}'.format(val)

help_string += '\n'

help_string += '\n\n'

if additional_definition:

help_string += 'Additionally:\n\n'

for item in sorted(additional_definition.items()):

help_string += '\t{}: {}\n'.format(*item)

help_string += '\n'

"""

delim = ", "

end = ".."

if isinstance(val, six.string_types):

if max_chars <= len("'" + end + "'"):

return ' ' * max_chars

elif add_delim and max_chars <= len("'" + end + "'") + len(delim):

return "'" + end + "'" + ' ' * (max_chars - len("'" + end + "'"))

else:

if max_chars <= len(end):

return ' ' * max_chars

elif add_delim and max_chars <= len(end) + len(delim):

return end + ' ' * (max_chars - len(end))

if add_delim:

max_chars -= len(delim)

r = repr(val)

if len(r) > max_chars:

if isinstance(val, six.string_types):

# TODO: can we assume this ends in "'"

r = r[:max_chars - len(end + "'")] + end + "'"

elif (isinstance(val, list) and

max_chars >= len("[{end}]".format(end=end))):

r = r[:max_chars - len(end + ']')] + end + ']'

else:

r = r[:max_chars - len(end)] + end

if add_delim:

r += delim

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)

"""

is_special = key in 'rtxyz'