forked from plotly/plotly.py
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathgrid_objs.py
More file actions
190 lines (157 loc) · 5.75 KB
/
grid_objs.py
File metadata and controls
190 lines (157 loc) · 5.75 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
"""
grid_objs
=========
"""
from __future__ import absolute_import
import json
from collections import MutableSequence
from plotly import exceptions
from plotly import utils
__all__ = None
class Column(object):
"""
Columns make up Plotly Grids and can be the source of
data for Plotly Graphs.
They have a name and an array of data.
They can be uploaded to Plotly with the `plotly.plotly.grid_ops`
class.
Usage example 1: Upload a set of columns as a grid to Plotly
```
from plotly.grid_objs import Grid, Column
import plotly.plotly as py
column_1 = Column([1, 2, 3], 'time')
column_2 = Column([4, 2, 5], 'voltage')
grid = Grid([column_1, column_2])
py.grid_ops.upload(grid, 'time vs voltage')
```
Usage example 2: Make a graph based with data that is sourced
from a newly uploaded Plotly columns
```
import plotly.plotly as py
from plotly.grid_objs import Grid, Column
from plotly.graph_objs import Scatter
# Upload a grid
column_1 = Column([1, 2, 3], 'time')
column_2 = Column([4, 2, 5], 'voltage')
grid = Grid([column_1, column_2])
py.grid_ops.upload(grid, 'time vs voltage')
# Build a Plotly graph object sourced from the
# grid's columns
trace = Scatter(xsrc=grid[0], ysrc=grid[1])
py.plot([trace], filename='graph from grid')
```
"""
def __init__(self, data, name):
"""
Initialize a Plotly column with `data` and `name`.
`data` is an array of strings, numbers, or dates.
`name` is the name of the column as it will apppear
in the Plotly grid. Names must be unique to a grid.
"""
# TODO: data type checking
self.data = data
# TODO: name type checking
self.name = name
self.id = ''
def __str__(self):
max_chars = 10
jdata = json.dumps(self.data, cls=utils.PlotlyJSONEncoder)
if len(jdata) > max_chars:
data_string = jdata[:max_chars] + "...]"
else:
data_string = jdata
string = '<name="{name}", data={data_string}, id={id}>'
return string.format(name=self.name, data=data_string, id=self.id)
def __repr__(self):
return 'Column("{0}", {1})'.format(self.data, self.name)
def to_plotly_json(self):
return {'name': self.name, 'data': self.data}
class Grid(MutableSequence):
"""
Grid is Plotly's Python representation of Plotly Grids.
Plotly Grids are tabular data made up of columns. They can be
uploaded, appended to, and can source the data for Plotly
graphs.
A plotly.grid_objs.Grid object is essentially a list.
Usage example 1: Upload a set of columns as a grid to Plotly
```
from plotly.grid_objs import Grid, Column
import plotly.plotly as py
column_1 = Column([1, 2, 3], 'time')
column_2 = Column([4, 2, 5], 'voltage')
grid = Grid([column_1, column_2])
py.grid_ops.upload(grid, 'time vs voltage')
```
Usage example 2: Make a graph based with data that is sourced
from a newly uploaded Plotly columns
```
import plotly.plotly as py
from plotly.grid_objs import Grid, Column
from plotly.graph_objs import Scatter
# Upload a grid
column_1 = Column([1, 2, 3], 'time')
column_2 = Column([4, 2, 5], 'voltage')
grid = Grid([column_1, column_2])
py.grid_ops.upload(grid, 'time vs voltage')
# Build a Plotly graph object sourced from the
# grid's columns
trace = Scatter(xsrc=grid[0], ysrc=grid[1])
py.plot([trace], filename='graph from grid')
```
"""
def __init__(self, iterable_of_columns):
"""
Initialize a grid with an iterable of
`plotly.grid_objs.Column objects
Usage example:
```
column_1 = Column([1, 2, 3], 'time')
column_2 = Column([4, 2, 5], 'voltage')
grid = Grid([column_1, column_2])
```
"""
# TODO: verify that columns are actually columns
column_names = [column.name for column in iterable_of_columns]
duplicate_name = utils.get_first_duplicate(column_names)
if duplicate_name:
err = exceptions.NON_UNIQUE_COLUMN_MESSAGE.format(duplicate_name)
raise exceptions.InputError(err)
self._columns = list(iterable_of_columns)
self.id = ''
def __repr__(self):
return self._columns.__repr__()
def __getitem__(self, index):
return self._columns[index]
def __setitem__(self, index, column):
self._validate_insertion(column)
return self._columns.__setitem__(index, column)
def __delitem__(self, index):
del self._columns[index]
def __len__(self):
return len(self._columns)
def insert(self, index, column):
self._validate_insertion(column)
self._columns.insert(index, column)
def _validate_insertion(self, column):
"""
Raise an error if we're gonna add a duplicate column name
"""
existing_column_names = [col.name for col in self._columns]
if column.name in existing_column_names:
err = exceptions.NON_UNIQUE_COLUMN_MESSAGE.format(column.name)
raise exceptions.InputError(err)
def _to_plotly_grid_json(self):
grid_json = {'cols': {}}
for column_index, column in enumerate(self):
grid_json['cols'][column.name] = {
'data': column.data,
'order': column_index
}
return grid_json
def get_column(self, column_name):
""" Return the first column with name `column_name`.
If no column with `column_name` exists in this grid, return None.
"""
for column in self._columns:
if column.name == column_name:
return column