Removes the metadata getLate from ar-catalog and adds the column
    getDueDate
768341
def update_analaysisrequests_due_date(portal):
    """"""
    logger.info("Updating getLate -> getDueDate metadata columns ...")
    catalog_objects = False
    catalog = api.get_tool(CATALOG_ANALYSIS_REQUEST_LISTING)
    if "getLate" in catalog.schema():
        catalog.delColumn("getLate")

    if "getDueDate" in catalog.schema():
        logger.info("getDueDate column already in catalog [SKIP]")
    else:
        logger.info("Adding column 'getDueDate' to catalog '{}' ..."
                    .format(catalog.id))
        catalog.addColumn("getDueDate")
        catalog_objects = True

    if "getDueDate" in catalog.indexes():
        logger.info("getDueDate index already in catalog [SKIP]")
    else:
        logger.info("Adding index 'getDueDate' to catalog '{}'"
                    .format(catalog.id))
        catalog.addIndex("getDueDate", "DateIndex")
        if not catalog_objects:
            catalog.manage_reindexIndex("getDueDate")

    if catalog_objects:
        # Only recatalog the objects if the column getDueDate was not there
        num = 0
        query = dict(portal_type="AnalysisRequest")
        ar_brains = api.search(query, CATALOG_ANALYSIS_REQUEST_LISTING)
        total = len(ar_brains)
        for num, analysis_request in enumerate(ar_brains):
            analysis_request = api.get_object(analysis_request)
            analysis_request.reindexObject(idxs=['getDueDate'])
            if num % 100 == 0:
                logger.info("Updating Analysis Request getDueDate: {0}/{1}"
                            .format(num, total))
        logger.info("{} Analysis Requests updated".format(num))

    logger.info("Updating getLate -> getDueDate metadata columns [DONE]")
46964
void removeFromIndex(SchemaStoreItem item) {
    schemaIndex.remove(item.getSchema().getLongID());
    item.setStream(null);
  }
717984
def remove_object_metadata_key(self, container, obj, key, prefix=None):
        
        self.set_object_metadata(container, obj, {key: ""}, prefix=prefix)
39541
def _addColumn(cat, col):
    
    # First check if the metadata column already exists
    if col not in cat.schema():
        try:
            cat.addColumn(col)
            logger.info('Column %s added to %s.' % (col, cat.id))
            return True
        except:
            logger.error(
                'Catalog column %s error while adding to %s.' % (col, cat.id))
    return False
131102
def _get_library_metadata(self, date_range):
        
        if date_range is None:
            raise Exception("A date range must be provided")
        if not (date_range.start and date_range.end):
            raise Exception("The date range {0} must contain a start and end date".format(date_range))

        start = date_range.start if date_range.start.tzinfo is not None else date_range.start.replace(tzinfo=mktz())
        end = date_range.end if date_range.end.tzinfo is not None else date_range.end.replace(tzinfo=mktz())
        query = {'$or': [{'start': {'$lte': start}, 'end': {'$gte': start}},
                         {'start': {'$gte': start}, 'end': {'$lte': end}},
                         {'start': {'$lte': end}, 'end': {'$gte': end}}]}

        cursor = self._collection.find(query,
                                       projection={'library_name': 1, 'start': 1, 'end': 1},
                                       sort=[('start', pymongo.ASCENDING)])

        results = []
        for res in cursor:
            start = res['start']
            if date_range.start.tzinfo is not None and start.tzinfo is None:
                start = start.replace(tzinfo=mktz("UTC")).astimezone(tz=date_range.start.tzinfo)

            end = res['end']
            if date_range.end.tzinfo is not None and end.tzinfo is None:
                end = end.replace(tzinfo=mktz("UTC")).astimezone(tz=date_range.end.tzinfo)

            results.append(TickStoreLibrary(res['library_name'], DateRange(start, end, CLOSED_CLOSED)))
        return results
1018771
@Override
	public void removeByLtD_S(Date displayDate, int status) {
		for (CPAttachmentFileEntry cpAttachmentFileEntry : findByLtD_S(
				displayDate, status, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
			remove(cpAttachmentFileEntry);
		}
	}
29667
def purge_catalogue(self, flag_vector):
        '''
        

        '''
        id0 = np.where(flag_vector)[0]
        self.select_catalogue_events(id0)
        self.get_number_events()
829379
function removeMediaEncoding (sdp, mediaType, encodingName) {
      var sdpLines = sdp.split('\r\n'),
          mLineIndex = SDPHelpers.getMLineIndex(sdpLines, mediaType),
          mLine = mLineIndex > -1 ? sdpLines[mLineIndex] : void 0,
          typesToRemove = [],
          payloadTypes,
          match;

      if (mLineIndex === -1) {
        // Error, missing M line
        return sdpLines.join('\r\n');
      }

      // Get all payload types that the line supports
      payloadTypes = SDPHelpers.getMLinePayloadTypes(mLine, mediaType);
      if (payloadTypes.length === 0) {
        // Error, invalid M line?
        return sdpLines.join('\r\n');
      }

      // Find the location of all the rtpmap lines that relate to +encodingName+
      // and any of the supported payload types
      var matcher = new RegExp('a=rtpmap:(' + payloadTypes.join('|') + ') ' +
                                            encodingName + '\\/\\d+', 'i');

      sdpLines = OT.$.filter(sdpLines, function(line, index) {
        match = line.match(matcher);
        if (match === null) return true;

        typesToRemove.push(match[1]);

        if (index < mLineIndex) {
          // This removal changed the index of the mline, track it
          mLineIndex--;
        }

        // remove this one
        return false;
      });

      if (typesToRemove.length > 0 && mLineIndex > -1) {
        // Remove all the payload types and we've removed from the media line
        sdpLines[mLineIndex] = SDPHelpers.removeTypesFromMLine(mLine, typesToRemove);
      }

      return sdpLines.join('\r\n');
    }
568869
@Override
	public void removeByLtD_S(Date displayDate, int status) {
		for (CPInstance cpInstance : findByLtD_S(displayDate, status,
				QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
			remove(cpInstance);
		}
	}
1066808
def _update_dates(self, **update_props):
        

        tree_to_update = update_props['tree_to_update']
        xpath_root = self._data_map['_dates_root']

        if self.dates:
            date_type = self.dates[DATE_TYPE]

            # First remove all date info from common root
            remove_element(tree_to_update, xpath_root)

            if date_type == DATE_TYPE_MULTIPLE:
                xpath_root += '/TempExtent/TM_Instant'
            elif date_type == DATE_TYPE_RANGE:
                xpath_root += '/TempExtent/TM_Period'

        return super(ArcGISParser, self)._update_dates(xpath_root, **update_props)
64866
def metadata(repository)
      end_date = DateTime.strptime(@date, "%Y-%m-%d")
      friendly_end_date = end_date.strftime("%B %d, %y")

      {
        sanitized_repository: repository.tr("/", "-"),
        repository: repository,
        date: end_date,
        friendly_date: friendly_end_date,
      }
    end
727193
private void removeDataBindings() {
        Bindings.unbindContent(detailedDayView.getCalendarSources(),
                getCalendarSources());
        Bindings.unbindContentBidirectional(
                detailedDayView.getCalendarVisibilityMap(),
                getCalendarVisibilityMap());
        Bindings.unbindContent(detailedWeekView.getCalendarSources(),
                getCalendarSources());
        Bindings.unbindContentBidirectional(
                detailedWeekView.getCalendarVisibilityMap(),
                getCalendarVisibilityMap());
        Bindings.unbindContent(monthView.getCalendarSources(),
                getCalendarSources());
        Bindings.unbindContentBidirectional(
                monthView.getCalendarVisibilityMap(),
                getCalendarVisibilityMap());
    }
915582
def _update_meta(self):
        
        for v in ["filename", "location", "prefix"]:
            if "meta" not in self:
                self["meta"] = {}
            self["meta"][v] = self[v]
            del self[v]
837853
public void clearMetaInfo(FacesContext context, UIComponent table) {
        context.getAttributes().remove(createKey(table));
    }
397610
private void updateMeta(Record r) {
        for(Map.Entry<Object, Object> entry : r.getX().entrySet()) {
            Object column = entry.getKey();
            Object value = entry.getValue();

            if(value!=null) {
                data.xDataTypes.putIfAbsent(column, TypeInference.getDataType(value));
            }
        }

        if(data.yDataType == null) {
            Object value = r.getY();
            if(value!=null) {
                data.yDataType = TypeInference.getDataType(r.getY());
            }
        }
    }
15352
def remove_metadata_key(self, key, prefix=None):
        
        self.manager.remove_metadata_key(self, key, prefix=prefix)
363691
private void clearMetadata(DeviceAnnouncement announcement) {
        final int player = announcement.getNumber();
        // Iterate over a copy to avoid concurrent modification issues
        for (DeckReference deck : new HashSet<DeckReference>(hotCache.keySet())) {
            if (deck.player == player) {
                hotCache.remove(deck);
                if (deck.hotCue == 0) {
                    deliverTrackMetadataUpdate(player, null);  // Inform listeners the metadata is gone.
                }
            }
        }
    }