Unregister this system from the insights service
197499
def unregister(self):
        
        machine_id = generate_machine_id()
        try:
            logger.debug("Unregistering %s", machine_id)
            url = self.api_url + "/v1/systems/" + machine_id
            net_logger.info("DELETE %s", url)
            self.session.delete(url)
            logger.info(
                "Successfully unregistered from the Red Hat Insights Service")
            return True
        except requests.ConnectionError as e:
            logger.debug(e)
            logger.error("Could not unregister this system")
            return False
275046
public void unregister(EventObserver<?> observer){
        for (Map.Entry<Class, Set<EventObserver>> entry : observers.entrySet()) {
            entry.getValue().remove(observer);
        }

    }
954077
def unregister(self, device, callback):
        
        if not device:
            logger.error("Received an invalid device: %r", device)
            return

        logger.debug("Removing subscription for {}".format(device.name))
        self._callbacks[device].remove(callback)
        self._devices[device.vera_device_id].remove(device)
1001285
def unregister(cls, panel):
        """"""
        success = Horizon.unregister_panel(cls, panel)
        if success:
            # Remove the panel's template directory.
            key = os.path.join(cls.slug, panel.slug)
            if key in loaders.panel_template_dirs:
                del loaders.panel_template_dirs[key]
        return success
92964
def unregister(self, signal):
        
        if signal in self.signals.keys():
            del(self.signals[signal])
            self.__log.debug("Signal %s unregisterd" % signal)
        else:
            self.__log.debug("Signal %s does not exist and could not be unregistered.")
263947
def _unregister_service(self):
        
        if self._registration is not None:
            # Ignore error
            try:
                self._registration.unregister()
            except BundleException as ex:
                # Only log the error at this level
                logger = logging.getLogger(
                    "-".join((self._ipopo_instance.name, "ServiceRegistration"))
                )
                logger.error("Error unregistering a service: %s", ex)

            # Notify the component (even in case of error)
            self._ipopo_instance.safe_callback(
                ipopo_constants.IPOPO_CALLBACK_POST_UNREGISTRATION,
                self._svc_reference,
            )

            self._registration = None
            self._svc_reference = None
1128109
def unregister(self, id):
        '''
        
        '''
        result = self.rr.table(self.table).get(id).delete().run()
        if result != {
                'deleted':1, 'errors':0,'inserted':0,
                'replaced':0,'skipped':0,'unchanged':0}:
            self.logger.warn(
                    'unexpected result attempting to delete id=%s from '
                    'rethinkdb services table: %s', id, result)
431718
def unlink(self):
        
        s_line_obj = self.env['sale.order.line']
        for line in self:
            if line.service_line_id:
                sale_unlink_obj = s_line_obj.browse([line.service_line_id.id])
                sale_unlink_obj.unlink()
        return super(HotelServiceLine, self).unlink()
716132
def remove(self, name):
        
        init = self._get_implementation(name)
        self._assert_service_installed(init, name)
        logger.info('Removing %s service %s...', self.init_system, name)
        init.stop()
        init.uninstall()
        logger.info('Service removed')
775298
def unregister(self, collector):
        """"""
        with self._lock:
            for name in self._collector_to_names[collector]:
                del self._names_to_collectors[name]
            del self._collector_to_names[collector]
207036
def unregisterFilter(self, column):
        
        if self._filters.has_key(column):
            del self._filters[column]
1021434
def unregisterHandler(self, fh):

        

        try:
            self.fds.remove(fh)

        except KeyError:
            pass

        self.lock.acquire()

        try:
            self.data.rollover() # rollover data on close.

        finally:
            self.lock.release()

        if self.closing and not self.fds:
            self.data.close()
683437
def unregisterPolling(self, fd, daemon = False):
        '''
        
        '''
        self.polling.unregister(fd, daemon)
1036729
def unregister_signals_oaiset(self):
        """"""
        from .models import OAISet
        from .receivers import after_insert_oai_set, \
            after_update_oai_set, after_delete_oai_set
        if contains(OAISet, 'after_insert', after_insert_oai_set):
            remove(OAISet, 'after_insert', after_insert_oai_set)
            remove(OAISet, 'after_update', after_update_oai_set)
            remove(OAISet, 'after_delete', after_delete_oai_set)
629836
def unregister_signals(self):
        """"""
        from .models import Collection
        from .percolator import collection_inserted_percolator, \
            collection_removed_percolator, collection_updated_percolator
        # Unregister Record signals
        if hasattr(self, 'update_function'):
            signals.before_record_insert.disconnect(self.update_function)
            signals.before_record_update.disconnect(self.update_function)
        # Unregister collection signals
        if contains(Collection, 'after_insert',
                    collection_inserted_percolator):
            remove(Collection, 'after_insert', collection_inserted_percolator)
            remove(Collection, 'after_update', collection_updated_percolator)
            remove(Collection, 'after_delete', collection_removed_percolator)
1245287
def remove_entry_listener(self, registration_id):
        
        return self._stop_listening(registration_id,
                                    lambda i: multi_map_remove_entry_listener_codec.encode_request(self.name, i))
654622
def unregistercls(self, schemacls=None, data_types=None):
    
    return _REGISTRY.unregistercls(schemacls=schemacls, data_types=data_types)