Removes a transition from the container state

        :param transition_id: the id of the transition to remove
        :raises exceptions.AttributeError: if the transition_id is already used
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)
481851
def remove_dnc(self, obj_id, channel):
        
        response = self._client.session.post(
            '{url}/{id}/dnc/remove/{channel}'.format(
                url=self.endpoint_url, id=obj_id, channel=channel
            )
        )
        return self.process_response(response)
798370
def remove(self, id):
        
        before_len = len(self.model.db)
        self.model.db = [t for t in self.model.db if t["id"] != id]
        if not self._batch.enable.is_set():
            self.model.save_db()
        return before_len - len(self.model.db)
33876
def delete(self, id):
        
        if id in self._images.keys():
            del self._images[id]
        self.tk.delete(id)
1232003
def delete_dampening(self, trigger_id, dampening_id):
        
        self._delete(self._service_url(['triggers', trigger_id, 'dampenings', dampening_id]))
562602
function(id) {
            var oldId = this.getId();

            Kinetic._removeId(oldId);
            Kinetic._addId(this, id);
            this._setAttr(ID, id);
            return this;
        }
1295475
public void removeRuleFlow(String id) {
        ProcessPackage rtp = (ProcessPackage) getResourceTypePackages().get(ResourceType.BPMN2);
        if (rtp == null || rtp.lookup(id) == null) {
            throw new IllegalArgumentException("The rule flow with id [" + id + "] is not part of this package.");
        }
        rtp.remove(id);
    }
1220895
def stop_instance(self, instance_id):
        
        instance = self._load_instance(instance_id)
        instance.delete()
        del self._instances[instance_id]
380671
def remove(self, transport):
        
        if transport.uid in self.transports:
            del (self.transports[transport.uid])
825240
def disconnect(self, id): # pylint: disable=invalid-name,redefined-builtin
        
        return self.service.post(self.base+str(id)+'/disconnect/')
150103
def remove_data_flows_with_data_port_id(self, data_port_id):
        
        if not self.is_root_state:
            # delete all data flows in parent related to data_port_id and self.state_id
            data_flow_ids_to_remove = []
            for data_flow_id, data_flow in self.parent.data_flows.items():
                if data_flow.from_state == self.state_id and data_flow.from_key == data_port_id or \
                        data_flow.to_state == self.state_id and data_flow.to_key == data_port_id:
                    data_flow_ids_to_remove.append(data_flow_id)

            for data_flow_id in data_flow_ids_to_remove:
                self.parent.remove_data_flow(data_flow_id)
1369735
public function removeTransition(Transition $transition)
    {
        if ($this->transitions->contains($transition)) {
            $this->transitions->removeElement($transition);
            $transition->setTask(null);
        }

        return $this;
    }
407057
def delete(id)
      unless Debugger.started? && Debugger.remove_breakpoint(id)
        raise ArgumentError, "No breakpoint ##{id}"
      end
      Pry.processor.debugging = false if to_a.empty?
    end
609755
def remove_uid(self, uid):
        
        for sid in self.get('uid2sid', uid):
            self.remove('sid2uid', sid, uid)
        self.delete('uid2sid', uid)
877620
def remove(self):
        

        if self._multiscat is None:
            return

        self._multiscat.deallocate(self.id)
        self._multiscat = None

        self._viewer_state.remove_global_callback(self._update_scatter)
        self.state.remove_global_callback(self._update_scatter)
416998
def destroy(self, recursive):
        
        for transition_id in list(self.transitions.keys()):
            self.remove_transition(transition_id, destroy=recursive)
        for data_flow_id in list(self.data_flows.keys()):
            self.remove_data_flow(data_flow_id, destroy=recursive)
        for scoped_variable_id in list(self.scoped_variables.keys()):
            self.remove_scoped_variable(scoped_variable_id, destroy=recursive)
        for state_id in list(self.states.keys()):
            if recursive:
                self.remove_state(state_id, recursive, force=True, destroy=recursive)
            else:
                del self.states[state_id]
        super(ContainerState, self).destroy(recursive)
606154
def remove_session_id(self, sid):
        
        for uid in self.get('sid2uid', sid):
            self.remove('uid2sid', uid, sid)
        self.delete('sid2uid', sid)

        for sub in self.get('sid2sub', sid):
            self.remove('sub2sid', sub, sid)
        self.delete('sid2sub', sid)