Return a ``<c:tx>`` oxml element for this series, containing the
        series name.
344897
def tx(self):
        
        xml = self._tx_tmpl.format(**{
            'wksht_ref':   self._series.name_ref,
            'series_name': self.name,
            'nsdecls':     ' %s' % nsdecls('c'),
        })
        return parse_xml(xml)
689930
def txn2epoch(self, txn: dict) -> int:
        

        rv = None
        if self == Protocol.V_13:
            rv = txn['result']['txnTime']
        else:
            rv = txn['result']['txnMetadata']['txnTime']

        return rv
190412
def _unpack_episode_title(element: ET.Element):
    """"""
    return EpisodeTitle(title=element.text,
                        lang=element.get(f'{XML}lang'))
19697
def series_index(self, series):
        
        for idx, s in enumerate(self):
            if series is s:
                return idx
        raise ValueError('series not in chart data object')
268786
def elementTypeName(self):
        
        dtype =  self._ncVar.dtype
        if type(dtype) == type:
            # Handle the unexpected case that dtype is a regular Python type
            # (happens e.g. in the /PROCESSOR/processing_configuration of the Trop LX files)
            return dtype.__name__

        return '<structured>' if dtype.names else str(dtype)
983634
def get_sequence_value(node):
        
        assert node.Datatype == 15
        data = defaultdict(list)
        cols = []
        for i in range(node.NumValues):
            row = node.GetValue(i)
            if i == 0:  # Get the ordered cols and assume they are constant
                cols = [str(row.GetElement(_).Name) for _ in range(row.NumElements)]

            for cidx in range(row.NumElements):
                col = row.GetElement(cidx)
                data[str(col.Name)].append(XmlHelper.as_value(col))
        return DataFrame(data, columns=cols)
910984
def to_dense(self):
        
        return Series(self.values.to_dense(), index=self.index,
                      name=self.name)
1214287
def add_series(self, name, number_format=None):
        
        series_data = XySeriesData(self, name, number_format)
        self.append(series_data)
        return series_data
845583
def get_pandas_series(self):
        """"""
        return pandas.Series(self.values, self.index, name=self.name)
246695
function assembleOtherSeries(series) {
    return zrUtil.map(series, function (series) {
        var data = series.getRawData();
        var lines = [series.name];
        var vals = [];
        data.each(data.dimensions, function () {
            var argLen = arguments.length;
            var dataIndex = arguments[argLen - 1];
            var name = data.getName(dataIndex);
            for (var i = 0; i < argLen - 1; i++) {
                vals[i] = arguments[i];
            }
            lines.push((name ? (name + ITEM_SPLITER) : '') + vals.join(ITEM_SPLITER));
        });
        return lines.join('\n');
    }).join('\n\n' + BLOCK_SPLITER + '\n\n');
}
616934
def get_value(self, series, key):
        
        if not is_scalar(key):
            raise InvalidIndexError

        k = com.values_from_object(key)
        loc = self.get_loc(k)
        new_values = com.values_from_object(series)[loc]

        return new_values
367370
def toxml(self):
        

        return '<Dimension name="{0}"'.format(self.name) +\
          (' m = "{0}"'.format(self.m) if self.m != 0 else '') +\
          (' l = "{0}"'.format(self.l) if self.l != 0 else '') +\
          (' t = "{0}"'.format(self.t) if self.t != 0 else '') +\
          (' i = "{0}"'.format(self.i) if self.i != 0 else '') +\
          (' k = "{0}"'.format(self.k) if self.k != 0 else '') +\
          (' n = "{0}"'.format(self.n) if self.n != 0 else '') +\
          (' j = "{0}"'.format(self.j) if self.j != 0 else '') +\
          '/>'
555048
def xs(self, key, axis=0, copy=False):
        
        if axis == 1:
            data = self[key]
            return data

        i = self.index.get_loc(key)
        data = self.take([i]).get_values()[0]
        return Series(data, index=self.columns)
921310
def elementTypeName(self):
        
        if self._array is None:
            return super(ArrayRti, self).elementTypeName
        else:
            dtype =  self._array.dtype
            return '<structured>' if dtype.names else str(dtype)
734801
def get_series(self, key):
        """"""

        url = make_series_url(key)
        resp = self.session.get(url)
        return resp
823779
def getColumnsByName(elem, name):
	
	name = StripColumnName(name)
	return elem.getElements(lambda e: (e.tagName == ligolw.Column.tagName) and (e.Name == name))
778987
def _value_format(self, value, serie, index):
        
        sum_ = serie.points[index][1]
        if serie in self.series and (
                self.stack_from_top
                and self.series.index(serie) == self._order - 1
                or not self.stack_from_top and self.series.index(serie) == 0):
            return super(StackedLine, self)._value_format(value)
        return '%s (+%s)' % (self._y_format(sum_), self._y_format(value))