Set the row/col labels.
        Note that this method doesn't check that enough labels were set for all the assigned positions.
165174
def set_labels(self, labels, axis='rows'):
        '''
        
        '''
        if axis.lower() in ('rows', 'row', 'r', 0):
            assigned_pos = set(v[0] for v in self._positions.itervalues())
            not_assigned = set(labels) - assigned_pos
            if len(not_assigned) > 0:
                msg = 'New labels must contain all assigned positions'
                raise ValueError(msg)
            self.row_labels = labels
        elif axis.lower() in ('cols', 'col', 'c', 1):
            self.col_labels = labels
        else:
            raise TypeError('Unsupported axis value %s' % axis)
654667
public void setRow(int row, double[] columns) {
        checkIndices(row, columns.length - 1);

        if (cols <= columns.length)
            cols = columns.length;
        
        SparseDoubleVector rowVec = updateRow(row);

        for (int col = 0; col < cols; ++col) {
            double val = columns[col];
            rowVec.set(col, val);
        }
    }
695615
public void setColumns(final Integer cols) {
		if (cols != null && cols < 0) {
			throw new IllegalArgumentException("Must have zero or more columns");
		}
		Integer currColumns = getColumns();
		if (!Objects.equals(cols, currColumns)) {
			getOrCreateComponentModel().cols = cols;
		}
	}
849832
public void setLabel (String label)
    {
        _label.setText(label);
        _label.setVisible(!StringUtil.isBlank(label));
    }
1040093
public void setColumnCellStyles (int column, String... styles)
    {
        int rowCount = getRowCount();
        for (int row = 0; row < rowCount; ++row) {
            setStyleNames(row, column, styles);
        }
    }
419867
def set_xtick_labels(self, row, column, labels):
        
        subplot = self.get_subplot_at(row, column)
        subplot.set_xtick_labels(labels)
615423
def setColumns(self, columns):
        
        self.__columns = {}
        for name, column in columns.items():
            self.__columns[name] = column
            column.setSchema(self)
1235545
def set_label_elements(self, wanted_label_elements):
        
        if isinstance(wanted_label_elements, str):
            wanted_label_elements = [wanted_label_elements]

        # Figure out which desired label elements are missing
        missing_elements = [e for e in wanted_label_elements if getattr(self, e) is None]

        contained_elements = [e for e in ann_label_fields if getattr(self, e )is not None]

        if not contained_elements:
            raise Exception('No annotation labels contained in object')

        for e in missing_elements:
            self.convert_label_attribute(contained_elements[0], e)

        unwanted_label_elements = list(set(ann_label_fields)
                                       - set(wanted_label_elements))

        self.rm_attributes(unwanted_label_elements)

        return
658229
public void setColumns(List<ColumnDefEx> cols) {
        clearHead();
        datacols.clear();
        if (!Empty.is(cols)) datacols.addAll(cols); // head will be created later in onLoad() or by refreshColumns()
    }
619336
public void setWidget (int row, int column, Widget widget, int colSpan, String... styles)
    {
        setWidget(row, column, widget);
        if (colSpan > 0) {
            getFlexCellFormatter().setColSpan(row, column, colSpan);
        }
        setStyleNames(row, column, styles);
    }
403683
private void applySettings() {
		container.reset();
		// Now show an example of the number of different columns

		WPanel gridLayoutPanel = new WPanel();

		if (cbResponsive.isSelected()) {
			gridLayoutPanel.setHtmlClass(HtmlClassProperties.RESPOND);
		}

		GridLayout layout = new GridLayout(rowCount.getValue().intValue(), columnCount.getValue()
				.intValue(),
				hGap.getValue().intValue(),
				vGap.getValue().intValue()
		);

		gridLayoutPanel.setLayout(layout);

		addBoxes(gridLayoutPanel, boxCount.getValue().intValue()); // give approx 3 rows, with a different number
		// of boxes on the final row
		container.add(gridLayoutPanel);

		gridLayoutPanel.setVisible(cbVisible.isSelected());
	}
374947
def append(self, row_or_table):
        """"""
        if not row_or_table:
            return
        if isinstance(row_or_table, Table):
            t = row_or_table
            columns = list(t.select(self.labels)._columns.values())
            n = t.num_rows
        else:
            if (len(list(row_or_table)) != self.num_columns):
                raise Exception('Row should have '+ str(self.num_columns) + " columns")
            columns, n = [[value] for value in row_or_table], 1
        for i, column in enumerate(self._columns):
            if self.num_rows:
                self._columns[column] = np.append(self[column], columns[i])
            else:
                self._columns[column] = np.array(columns[i])
        self._num_rows += n
        return self
505299
public void setCustomTickmarkLabels(final double... CUSTOM_TICKMARK_LABELS_ARRAY) {
        customTickmarkLabels.clear();
        for (Double label : CUSTOM_TICKMARK_LABELS_ARRAY) {
            customTickmarkLabels.add(label);
        }
        reInitialize();
    }
1140846
def show_yticklabels_for_all(self, row_column_list=None):
        
        if row_column_list is None:
            for subplot in self.subplots:
                subplot.show_yticklabels()
        else:
            for row, column in row_column_list:
                self.show_yticklabels(row, column)
318974
def update_row(self, ind, row_data):
        
        if sorted(row_data.keys()) != sorted(self.df.columns):
            # add any new column names
            for key in row_data:
                if key not in self.df.columns:
                    self.df[key] = None
            # add missing column names into row_data
            for col_label in self.df.columns:
                if col_label not in list(row_data.keys()):
                    row_data[col_label] = None
        try:
            self.df.iloc[ind] = pd.Series(row_data)
        except IndexError:
            return False
        return self.df
944826
public void setLabels(List<String> labels) {
        if (labels.size() != this.labels.size()) {
            throw new IllegalArgumentException("You need to provide " + this.labels.size() + " labels.");
        }
        this.labels = labels;
        ((ArrayAdapter<String>) getAdapter()).notifyDataSetChanged();
    }
861532
def set_value(self, labels, value):
        

        if labels:
            self._label_names_correct(labels)

        with mutex:
            self.values[labels] = value