remove a :class:`Router` from the :attr:`routes` list.
557914
def remove_child(self, router):
        ''''''
        if router in self.routes:
            self.routes.remove(router)
            router._parent = None
424672
def reset(self, route=None):
        '''  '''
        if route is None: routes = self.routes
        elif isinstance(route, Route): routes = [route]
        else: routes = [self.routes[route]]
        for route in routes: route.reset()
        if DEBUG:
            for route in routes: route.prepare()
        self.trigger_hook('app_reset')
452866
def delete_route_table(route_table_id=None, route_table_name=None,
                       region=None, key=None, keyid=None, profile=None):
    '''
    

    '''
    return _delete_resource(resource='route_table', name=route_table_name,
                            resource_id=route_table_id, region=region, key=key,
                            keyid=keyid, profile=profile)
981463
def delete_filter(filter_class)
      index = @filters.index { |f| f.class.name == filter_class.name }
      @filters.delete_at(index) if index
    end
1217157
def reset(self, route=None):
        '''  '''
        if route is None: routes = self.routes
        elif isinstance(route, Route): routes = [route]
        else: routes = [self.routes[route]]
        for route in routes: route.reset()
        if DEBUG:
            for route in routes: route.prepare()
        self.hooks.trigger('app_reset')
368066
def RemoveClass(self, class_name):
    
    if class_name not in self._class_mapping:
      raise problems.NonexistentMapping(class_name)
    del self._class_mapping[class_name]
988871
def remove_rule(self, name):
        
        self._rule_attrs.remove(name)
        delattr(self, name)
186153
def _remove_wrappers(self):
        
        ansible_mitogen.loaders.action_loader.get = action_loader__get
        ansible_mitogen.loaders.connection_loader.get = connection_loader__get
        ansible.executor.process.worker.WorkerProcess.run = worker__run
391986
def removeAttribute(self, attrName):
        '''
            

        '''
        attrName = attrName.lower()

        # Delete provided attribute name ( #attrName ) from attributes map
        try:
            del self._attributes[attrName]
        except KeyError:
            pass
396672
function remove(route, callback, context){
    var route = get({
      path: route
    });

    if (!route)
      return;

    for (var i = 0, cb; cb = route.callbacks_[i]; i++)
    {
      if (cb.cb_ === callback && cb.context === context)
      {
        route.callbacks_.splice(i, 1);

        if (route.value && callback && callback.leave)
        {
          callback.leave.call(context);

          /** @cut */ if (module.exports.debug)
          /** @cut */   basis.dev.info(
          /** @cut */     namespace + ': add handler for route `' + path + '`\n',
          /** @cut */     { type: 'leave', path: route.path, cb: callback.leave, route: route }
          /** @cut */   );
        }

        if (!route.callbacks_.length)
        {
          // check no attaches to route
          if ((!route.handler || !route.handler.handler) && !route.matched.handler)
          {
            basis.array.remove(allRoutes, route);

            if (!(route instanceof ParametrizedRoute))
              delete plainRoutesByPath[route.path];
          }
        }

        return;
      }
    }
    /** @cut */ basis.dev.warn(namespace + ': no callback removed', { callback: callback, context: context });
  }
1315729
def remove_from_pythonpath(self, path):
        """"""
        pathlist = self.get_pythonpath()
        if path in pathlist:
            pathlist.pop(pathlist.index(path))
            self.set_pythonpath(pathlist)
            return True
        else:
            return False
1080557
def delete_router_references(self, snet, address=None, dnets=None):
        """"""
        if _debug: NetworkServiceAccessPoint._debug("delete_router_references %r %r %r", snet, address, dnets)

        # see if we have an adapter for the snet
        if snet not in self.adapters:
            raise RuntimeError("no adapter for network: %d" % (snet,))

        # pass this along to the cache
        self.router_info_cache.delete_router_info(snet, address, dnets)
194148
def remove_router_from_hosting_device(self, client, hosting_device_id,
                                          router_id):
        """"""
        res_path = hostingdevice.HostingDevice.resource_path
        return client.delete((res_path + DEVICE_L3_ROUTERS + "/%s") % (
            hosting_device_id, router_id))
657063
def cleanup(self):
        """"""
        for _id, shard in self._shards.items():
            if shard.get('isServer', False):
                Servers().remove(shard['_id'])
            if shard.get('isReplicaSet', False):
                ReplicaSets().remove(shard['_id'])

        for mongos in self._routers:
            Servers().remove(mongos)

        for config_id in self._configsvrs:
            self.configdb_singleton.remove(config_id)

        self._configsvrs = []
        self._routers = []
        self._shards = {}
310628
def delt(self, *args, **kargs):
        """"""
        self.invalidate_cache()
        route = self.make_route(*args, **kargs)
        try:
            i = self.routes.index(route)
            del(self.routes[i])
        except ValueError:
            warning("no matching route found")
900765
def remove(self, name):
        
        attrs = [attr for attr in self.attributes if attr.name == name.strip()]
        if not attrs:
            raise ValueError(name)
        for attr in attrs:
            self.attributes.remove(attr)
173966
def remove_class(cls, *args):
        
        for cls2 in args:
            try:
                del cls.classes[cls2.__name__]
            except KeyError:
                pass