Unregister a matcher (or alias) from the registry
337624
def unregister(matcher):
    
    # If it's a string handle it like an alias
    if isinstance(matcher, text_types) and matcher in matchers:
        matcher = matchers[matcher]

    # Find all aliases associated to the matcher
    aliases = [k for k, v in matchers.iteritems() if v == matcher]
    for alias in aliases:
        del matchers[alias]
        # Clean up the normalized versions
        norms = [k for k, v in normalized.iteritems() if v == alias]
        for norm in norms:
            del normalized[norm]

    # Remove help docstring
    if matcher in helpmatchers:
        del helpmatchers[matcher]

    return len(aliases) > 0
514660
private void unregisterNamespace(String prefix, boolean persist) throws NamespaceException, RepositoryException
   {
      if (namespaces.get(prefix) == null)
      {
         throw new NamespaceException("Prefix " + prefix + " is not registered");
      }

      if (PROTECTED_NAMESPACES.contains(prefix))
      {
         throw new NamespaceException("Prefix " + prefix + " is protected");
      }
      String uri = getURI(prefix);
      if (indexSearcherHolder != null)
      {
         final Set<String> nodes = indexSearcherHolder.getNodesByUri(uri);
         if (nodes.size() > 0)
         {
            StringBuilder builder = new StringBuilder();
            builder.append("Fail to unregister namespace '");
            builder.append(prefix);
            builder.append("' because of following nodes:  ");

            for (String uuid : nodes)
            {
               ItemData item = dataManager.getItemData(uuid);
               if (item != null && item.isNode())
               {
                  builder.append(" - ");
                  builder.append(item.getQPath().getAsString());
                  builder.append("\r\n");
               }
            }
            builder.append(" uses this prefix.");
            throw new NamespaceException(builder.toString());
         }
      }
      prefixes.remove(uri);
      namespaces.remove(prefix);
      if (persister != null && persist)
      {
         persister.removeNamespace(prefix);
      }
   }
275046
public void unregister(EventObserver<?> observer){
        for (Map.Entry<Class, Set<EventObserver>> entry : observers.entrySet()) {
            entry.getValue().remove(observer);
        }

    }
1215663
def unregister(model_or_iterable, fail_silently=False):
    '''
    
    '''
    from django.db import models
    from .compat import get_model

    if issubclass(model_or_iterable, models.Model):
        model_or_iterable = [model_or_iterable]
    for model in model_or_iterable:
        if isinstance(model, string_types):
            model = get_model(*model.split('.', 1))
        try:
            del REGISTRY[model]
        except KeyError:
            if fail_silently:
                continue
            raise ValueError(
                u'The model %s.%s is not registered.' % (
                    model._meta.app_label,
                    model._meta.object_name,
                ))
302292
function unregister() {
      for (var p = d.wrapper.parentNode; p && p != document.body; p = p.parentNode) {}
      if (p) setTimeout(unregister, 5000);
      else off(window, "resize", onResize);
    }
867854
def unregister_callback(callback_id):
    """"""
    global _callbacks
    obj = _callbacks.pop(callback_id, None)
    threads = []
    if obj is not None:
        t, quit = obj
        quit.set()
        threads.append(t)
    for t in threads:
        t.join()
68861
def unregister(self, recipe):
        
        recipe = self.get_recipe_instance_from_class(recipe)
        if recipe.slug in self._registry:
            del self._registry[recipe.slug]
1268654
def unregister(self, name: str):
        ''''''
        del self._callbacks[name]

        if self._event_dispatcher is not None:
            self._event_dispatcher.unregister(name)
638404
def unregisterAPI(self, name):
        
        if name.startswith('public/'):
            target = 'public'
            name = name[len('public/'):]
        else:
            target = self.servicename
            name = name
        removes = [m for m in self.handler.handlers.keys() if m.target == target and m.name == name]
        for m in removes:
            self.handler.unregisterHandler(m)
475156
def unregister(self, name):
        
        try:
            name = name.name
        except AttributeError:
            pass
        return self.pop(name,None)
372891
void unregisterUse() {
		final int value = this.uses.decrementAndGet();
		if (value == 0) {
			uninstall(UninstallationStage.PRE_DESTROY_EVENT);
			uninstall(UninstallationStage.POST_DESTROY_EVENT);
		}
	}
475447
private synchronized void unregisterAllSimons() {
		Iterator<String> namesIter = registeredNames.iterator();
		while (namesIter.hasNext()) {
			String name = namesIter.next();
			try {
				ObjectName objectName = new ObjectName(name);
				mBeanServer.unregisterMBean(objectName);
				// I have to use iterator.remove() - hence no common method for clearManager() and simonDestroyed(simon)
				namesIter.remove();
				onManagerMessage("Unregistered Simon with the name: " + objectName);
			} catch (JMException e) {
				onManagerWarning("JMX unregistration failed for: " + name, e);
			}
		}
	}
683437
def unregisterPolling(self, fd, daemon = False):
        '''
        
        '''
        self.polling.unregister(fd, daemon)
234509
def unregister(self, itemtype, item_id):
        '''
        
        '''
        if itemtype not in [ZooConst.CLIENT, ZooConst.WORKER, ZooConst.BROKER]:
            raise Exception('Zooborg.unregister: invalid type')
        self.initconn()
        self.zk.ensure_path("/distark/" + itemtype + "/list")
        path=''.join(['/distark/' + itemtype + '/list/', item_id])
        if self.zk.exists(path):
            self.zk.delete(path, recursive=True)
841293
def register_get(self, regex, callback):
        
        if callback is None:                                                                    # pragma: no cover
            if regex in self.get_registrations:
                del self.get_registrations[regex]
        else:
            self.get_registrations[regex] = (re.compile(regex), callback)
1065573
public static void unregister() {
    synchronized (monitor) {
      checkState(handler != null, "Zipkin exporter is not registered.");
      unregister(Tracing.getExportComponent().getSpanExporter());
      handler = null;
    }
  }
666802
def unregister(self, slug):
        

        if slug not in self._registry:
            raise NotRegistered('The slug %s is not registered' % slug)
        bundle = self._registry[slug]
        if bundle._meta.model and bundle._meta.primary_model_bundle:
            self.unregister_model(bundle._meta.model)

        del self._registry[slug]
        del self._order[slug]