Descriptive data to be included in :meth:`index_data`
        output.  This implementation includes all Dublin Core fields,
        but should be extended or overridden as appropriate for custom
        :class:`~eulfedora.models.DigitalObject` classes.
518210
def index_data_descriptive(self):
        ''''''

        dc_fields = ['title', 'contributor', 'coverage', 'creator', 'date', 'description',
                     'format', 'identifier', 'language', 'publisher', 'relation',
                     'rights', 'source', 'subject', 'type']
        dc_data = {}
        for field in dc_fields:
            list_field = getattr(self.dc.content, '%s_list' % field)
            if list_field:
                # convert xmlmap lists to straight lists so simplejson can handle them
                dc_data[field] = list(list_field)
        return dc_data
1020847
def _add_metadata_as_attrs_da(data, units, description, dtype_out_vert):
    """"""
    if dtype_out_vert == 'vert_int':
        if units != '':
            units = '(vertical integral of {0}): {0} kg m^-2)'.format(units)
        else:
            units = '(vertical integral of quantity with unspecified units)'
    data.attrs['units'] = units
    data.attrs['description'] = description
    return data
1164626
def _pad_data(self, index_len):
        
        self._data.extend([None] * (index_len - len(self._data)))
1173636
def _parse_digital_forms(self, prop=DIGITAL_FORMS):
        

        xpath_map = self._data_structures[prop]

        # Parse base digital form fields: 'name', 'content', 'decompression', 'version', 'specification'
        xpath_root = self._data_map['_digital_forms_root']
        digital_forms = parse_complex_list(self._xml_tree, xpath_root, xpath_map, prop)

        # Parse digital form transfer option fields: 'access_desc', 'access_instrs', 'network_resource'
        xpath_root = self._data_map['_transfer_options_root']
        transfer_opts = parse_complex_list(self._xml_tree, xpath_root, xpath_map, prop)

        # Split out digital form content that has been appended to specifications

        content_delim = _DIGITAL_FORMS_CONTENT_DELIM

        for digital_form in digital_forms:
            specs = reduce_value(digital_form['specification'])
            specs = specs.splitlines() if isinstance(specs, string_types) else specs

            specifications = wrap_value(s.strip() for s in specs)

            digital_form['content'] = []
            digital_form['specification'] = []
            has_content = False

            # For each specification, insert delim before appending content
            for spec in specifications:
                has_content = has_content or spec == content_delim

                if not has_content:
                    digital_form['specification'].append(spec)
                elif spec != content_delim:
                    digital_form['content'].append(spec)

            # Reduce spec and content to single string values if possible
            for form_prop in ('content', 'specification'):
                digital_form[form_prop] = reduce_value(filter_empty(digital_form[form_prop], u''))

        # Combine digital forms and transfer options into a single complex struct

        df_len = len(digital_forms)
        to_len = len(transfer_opts)
        parsed_forms = []

        for idx in xrange(0, max(df_len, to_len)):
            digital_form = {}.fromkeys(_iso_definitions[prop], u'')

            if idx < df_len:
                digital_form.update(i for i in digital_forms[idx].items() if i[1])
            if idx < to_len:
                digital_form.update(i for i in transfer_opts[idx].items() if i[1])

            if any(digital_form.values()):
                parsed_forms.append(digital_form)

        return get_default_for_complex(prop, parsed_forms)
1055906
def _dataslice(self, data, indices):
        
        if self._deep_indexable and isinstance(data, Dimensioned) and indices:
            return data[indices]
        elif len(indices) > 0:
            self.param.warning('Cannot index into data element, extra data'
                               ' indices ignored.')
        return data
718420
def _export_all_keyword(self):
        
        data = {}
        for fluid_idx, fluid in enumerate(self.metadata["fluids"]):
            data[fluid] = {}
            with open(self.abspath) as fobj:
                text = fobj.read()
                try:
                    text = text.split("!Phase properties")[1+fluid_idx]
                except IndexError:
                    text = text.split("COLUMNS")[1+fluid_idx]
                try:
                    text = text.split("LABEL")[0]
                except IndexError:
                    pass
                values = re.findall(r"[\.\d\-]+[\.\deE\+\-]+", text)
            nprops = len(self.metadata["properties"])
            for idx, prop in enumerate(self.metadata["properties"]):
                data[fluid][prop] = [float(x) for x in values[idx::nprops]]
        self.data = pd.DataFrame(data)
928929
def _data(self, copy=False):
        
        data = {}
        for key, obj in self.__dict__.items():
            if isinstance(obj, (pd.Series, pd.DataFrame, pd.SparseSeries, pd.SparseDataFrame)):
                if copy:
                    data[key] = obj.copy()
                else:
                    data[key] = obj
        return data
744961
def index_data(self, data, index_name, doc_type):
        """"""

        print 'ELS Stub Indexer getting called...'
        print '%s %s %s %s' % (self, data, index_name, doc_type)
1031108
def indexables(self):
        
        if self._indexables is None:

            d = self.description

            # the index columns is just a simple index
            self._indexables = [GenericIndexCol(name='index', axis=0)]

            for i, n in enumerate(d._v_names):

                dc = GenericDataIndexableCol(
                    name=n, pos=i, values=[n], version=self.version)
                self._indexables.append(dc)

        return self._indexables
1102341
def describe(df, dtype=None):
    
    if dtype is None:
        dtype = {}
    print('Number of datapoints: {datapoints}'.format(datapoints=len(df)))
    column_info, column_info_meta = _get_column_info(df, dtype)

    if len(column_info['int']) > 0:
        _describe_int(df, column_info)

    if len(column_info['float']) > 0:
        _describe_float(df, column_info)

    if len(column_info['category']) > 0:
        _describe_category(df, column_info, column_info_meta)

    if len(column_info['time']) > 0:
        _describe_time(df, column_info, column_info_meta)

    if len(column_info['other']) > 0:
        _describe_other(df, column_info, column_info_meta)

    column_types = {}
    for column_type, columns in column_info.items():
        for column_name in columns:
            if column_type == 'other':
                column_type = 'str'
            column_types[column_name] = column_type
    return column_types
90218
def _data(self, copy=False):
        
        data = {}
        for key, obj in vars(self).items():
            if isinstance(obj, (pd.Series, pd.DataFrame, pd.SparseSeries, pd.SparseDataFrame)):
                if copy:
                    data[key] = obj.copy(deep=True)
                else:
                    data[key] = obj
        return data
283438
def index_data(self):
        
        # Start index for the Data Object
        index = Index(0, 0, self.address, self.base_address, False)
        # Container
        if is_container(self._data):
            self._data.index_fields(index, nested=True)
        # Pointer
        elif is_pointer(self._data):
            self._data.index_field(index)
            self._data.index_data()
        # Field
        elif is_field(self._data):
            self._data.index_field(index)
230021
private String emitDataTypes() {
    StringBuilder dtDefs = new StringBuilder();
    while (emittedDatatypes.size() < datatypes.size()) {
      for (String dt : new HashSet<String>(datatypes)) {
        if (!emittedDatatypes.contains(dt)) {
          StructureDefinition sd = context.fetchResource(StructureDefinition.class,
              ProfileUtilities.sdNs(dt, null));
          // TODO: Figure out why the line below doesn't work
          // if (sd != null && !uniq_structures.contains(sd))
          if(sd != null && !uniq_structure_urls.contains(sd.getUrl()))
            dtDefs.append("\n").append(genShapeDefinition(sd, false));
          emittedDatatypes.add(dt);
        }
      }
    }
    return dtDefs.toString();
  }
1104763
def describe(self, **kwargs):
        
        response = self._new_response()
        description = {
            'cruddy_version': __version__,
            'table_name': self.table_name,
            'supported_operations': copy.copy(self.supported_ops),
            'prototype': copy.deepcopy(self.prototype),
            'operations': {}
        }
        for name, method in inspect.getmembers(self, inspect.ismethod):
            if not name.startswith('_'):
                argspec = inspect.getargspec(method)
                if argspec.defaults is None:
                    defaults = None
                else:
                    defaults = list(argspec.defaults)
                method_info = {
                    'docs': inspect.getdoc(method),
                    'argspec': {
                        'args': argspec.args,
                        'varargs': argspec.varargs,
                        'keywords': argspec.keywords,
                        'defaults': defaults
                    }
                }
                description['operations'][name] = method_info
        response.data = description
        return response
1306632
def data(self, index, role=QtCore.Qt.UserRole):
        
        if role == QtCore.Qt.DisplayRole:
            row = index.row()
            field = self._headers[index.column()]
            val = self.model.paramValue(row, field)
            if 1 <= index.column() <= 3:
                # standard units for data, not necessary current for UI
                # view will scale and convert appropriately
                unit = self.model.getDetail(index.row(), 'unit')
                if val is not None and unit is not None:
                    return str(val) + ' ' + unit
                else:
                    return val
            else:
                return val

        elif role == QtCore.Qt.EditRole:
            row = index.row()
            field = self._headers[index.column()]
            return self.model.paramValue(row, field)
            # return self.model.paramValue(row, field)
        elif role == QtCore.Qt.ForegroundRole:
            # color the background red for bad values
            if not self.checkValidCell(index):
                return QtGui.QBrush(ERRCELL)
        elif role == QtCore.Qt.FontRole:
            # color the background red for bad values
            if not self.checkValidCell(index):
                f = QtGui.QFont()
                f.setWeight(QtGui.QFont.Bold)
                return f

        elif role == QtCore.Qt.UserRole or role == AbstractDragView.DragRole:  #return the whole python object
            param = self.model.param(index.row())
            for comp in param['selection']:
                comp.clean()
            return param

        elif role == self.SelectionModelRole:
            # may need to translate to QModelIndexes
            return self.model.selection(self.model.param(index.row()))
        
        elif role == CursorRole:
            col = index.column()
            if not index.isValid():
                return QtGui.QCursor(QtCore.Qt.ArrowCursor)
            elif col == 0:
                return cursors.pointyHand()
            elif col < 4:
                return cursors.handEdit()
            else:
                return cursors.openHand()
932626
def add_data(self, data):  # add append option later
        
        df = pd.DataFrame(data)
        name, dtype = self.get_singular_and_plural_dtype(self.dtype)
        if name in df.columns:
            df.index = df[name]
        df.index.name = name + " name"
        self.df = df
1173209
function() {
    var includes = "#include <ConfigurableFirmata.h>\n\n";

    includes += this.transport.createConfigBlock();

    for (var i = 0, len = this.selectedFeatures.length; i < len; i++) {
      var feature = this.allFeatures[this.selectedFeatures[i]];

      if (feature.dependencies) {
        for (var j = 0; j < feature.dependencies.length; j++) {
          var d = feature.dependencies[j];
          // prevent duplicate includes
          if (d.className && !this.dependencies[d.className]) {
            includes += "#include <" + d.className + ".h>\n";
            this.dependencies[d.className] = true;
          }
        }
      }

      includes += "#include <" + feature.className + ".h>\n";
      includes += feature.className + " " + feature.instanceName + ";\n\n";
    }

    // necessary until Servo can be decoupled from analog output
    if (servoEnabled && !analogOutputEnabled) {
      includes += "#include <AnalogOutputFirmata.h>\n";
      includes += "AnalogOutputFirmata analogOutput;\n\n";
    }

    // always include FirmataExt
    includes += "#include <FirmataExt.h>\n";
    includes += "FirmataExt firmataExt;\n\n";

    return includes;
  }