Remove the state machine for a specified state machine id from the list of registered state machines.

        :param state_machine_id: the id of the state machine to be removed
330923
def remove_state_machine(self, state_machine_id):
        
        import rafcon.core.singleton as core_singletons
        removed_state_machine = None
        if state_machine_id in self._state_machines:
            logger.debug("Remove state machine with id {0}".format(state_machine_id))
            removed_state_machine = self._state_machines.pop(state_machine_id)
        else:
            logger.error("There is no state_machine with state_machine_id: %s" % state_machine_id)
            return removed_state_machine

        # destroy execution history
        removed_state_machine.destroy_execution_histories()
        return removed_state_machine
1064492
def register_states_of_state_machine(self, state_machine):
        
        root = state_machine.root_state
        root.add_observer(self, "state_execution_status",
                          notify_after_function=self.on_state_execution_status_changed_after)
        self.recursively_register_child_states(root)
1062831
public void remove(String ID) {
        String[] stv = TransliteratorIDParser.IDtoSTV(ID);
        // Only need to do this if ID.indexOf('-') < 0
        String id = TransliteratorIDParser.STVtoID(stv[0], stv[1], stv[2]);
        registry.remove(new CaseInsensitiveString(id));
        removeSTV(stv[0], stv[1], stv[2]);
        availableIDs.remove(new CaseInsensitiveString(id));
    }
1125087
def remove(self, repl_id):
        
        repl = self._storage.pop(repl_id)
        repl.cleanup()
        del(repl)
248282
def delete_one(self, id_):
                
        url = "https://api.knackhq.com/v1/objects/%s/records/%s" % (
            self.key, id_)
        res = self.delete(url)
        return res
910888
def remove_service_checks(self, service_id):
    
    from hypermap.aggregator.models import Service
    service = Service.objects.get(id=service_id)

    service.check_set.all().delete()
    layer_to_process = service.layer_set.all()
    for layer in layer_to_process:
        layer.check_set.all().delete()
1010766
def delete_rule(self, rule_id):
        
        if rule_id not in self.rules:
            LOG.error("No Rule id present for deleting %s", rule_id)
            return
        del self.rules[rule_id]
        self.rule_cnt -= 1
516786
def remove_transition(self, transition_id, destroy=True):
        
        if transition_id == -1 or transition_id == -2:
            raise AttributeError("The transition_id must not be -1 (Aborted) or -2 (Preempted)")
        if transition_id not in self._transitions:
            raise AttributeError("The transition_id %s does not exist" % str(transition_id))

        self.transitions[transition_id].parent = None
        return self.transitions.pop(transition_id)
1170984
def get_active_state_machine(self):
        
        if self._active_state_machine_id in self._state_machines:
            return self._state_machines[self._active_state_machine_id]
        else:
            return None
720783
def delete(self, ids):
        
        url = build_uri_with_ids('api/v4/equipment/%s/', ids)
        return super(ApiV4Equipment, self).delete(url)
1292825
def relieve_state_machines(self, model, prop_name, info):
        
        if info['method_name'] == '__setitem__':
            pass
        elif info['method_name'] == '__delitem__':
            self.relieve_model(self.state_machine_manager_model.state_machines[info['args'][0]])
            if self.state_machine_manager_model.state_machines[info['args'][0]].root_state:
                self.relieve_model(self.state_machine_manager_model.state_machines[info['args'][0]].root_state)
                # otherwise relieved by root_state assign notification
            # self.logger.info(NotificationOverview(info))
        else:
            self.logger.warning(NotificationOverview(info))
756371
async def destroy(self, force=False):
        
        facade = client.ClientFacade.from_connection(self.connection)

        log.debug(
            'Destroying machine %s', self.id)

        await facade.DestroyMachines(force, [self.id])
        return await self.model._wait(
            'machine', self.id, 'remove')
1018720
def remove(cls, id):
        

        api = Client.instance().api
        api.index(id).delete()
548806
def state_machine_destruction(self, model, prop_name, info):
        
        if self.model is model:  # only used for the state machine destruction case
            self.canvas.get_view_for_model(self.root_state_m).remove()
213895
def remove(self, membership_id):
        
        path = '{}/remove'.format(membership_id)
        url = utils.urljoin(self.url, path)
        payload = {'membership_id': membership_id}
        response = self.session.post(url, json=payload)
        return response.ok
1010339
def remove_listener(self, registration_id):
        
        try:
            self._listeners.pop(registration_id)
            return True
        except KeyError:
            return False
342621
def remove(self, processor_identity):
        
        with self._condition:
            processor_types = self._identities.get(processor_identity)
            if processor_types is None:
                LOGGER.warning("transaction processor with identity %s tried "
                               "to unregister but was not registered",
                               processor_identity)
                return
            for processor_type in processor_types:
                if processor_type not in self._processors:
                    LOGGER.warning("processor type %s not a known processor "
                                   "type but is associated with identity %s",
                                   processor_type,
                                   processor_identity)
                    continue
                self._processors[processor_type].remove_processor(
                    processor_identity=processor_identity)
                if not self._processors[processor_type]:
                    del self._processors[processor_type]