Remove an output data port from the state

        :param int data_port_id: the id of the output data port to remove
        :raises exceptions.AttributeError: if the specified input data port does not exist
516477
def remove_output_data_port(self, data_port_id, force=False, destroy=True):
        
        if data_port_id in self._output_data_ports:
            if destroy:
                self.remove_data_flows_with_data_port_id(data_port_id)
            self._output_data_ports[data_port_id].parent = None
            return self._output_data_ports.pop(data_port_id)
        else:
            raise AttributeError("output data port with name %s does not exit", data_port_id)
1209223
def remove_tcp_port(self, port):
        

        if port in self._used_tcp_ports:
            self._used_tcp_ports.remove(port)
636422
def delete(self, resource_id):
        

        endpoint = '{}/{}'.format(self.endpoint, resource_id)

        response = self.api.execute("DELETE", endpoint)

        if not response.ok:
            raise Error.parse(response.json())

        return self._cls.parse(response.json())
987118
def _apply_new_data_port_name(self, path, new_name):
        
        try:
            data_port_id = self.list_store[path][self.ID_STORAGE_ID]
            if self.state_data_port_dict[data_port_id].name != new_name:
                self.state_data_port_dict[data_port_id].name = new_name
        except (TypeError, ValueError) as e:
            logger.exception("Error while trying to change data port name")
1294677
def delete_port(self, port):
        '''
        
        '''
        port_id = self._find_port_id(port)
        ret = self.network_conn.delete_port(port=port_id)
        return ret if ret else True
642815
def release_filename(self, id_):
        

        entry = self.__entries.get(id_)
        if entry is None:
            raise ValueError("Invalid filename id (%d)" % id_)

        # Decrease reference count and check if the entry has to be removed...
        if entry.dec_ref_count() == 0:
            del self.__entries[id_]
            del self.__id_lut[entry.filename]
187215
async def disconnect(self, conn_id):
        

        adapter_id = self._get_property(conn_id, 'adapter')
        await self.adapters[adapter_id].disconnect(conn_id)

        self._teardown_connection(conn_id)
256238
def remove_port(zone, port, permanent=True):
    '''
    
    '''
    cmd = '--zone={0} --remove-port={1}'.format(zone, port)

    if permanent:
        cmd += ' --permanent'

    return __firewall_cmd(cmd)
1016461
def remove_data_flow(self, data_flow_id, destroy=True):
        
        if data_flow_id not in self._data_flows:
            raise AttributeError("The data_flow_id %s does not exist" % str(data_flow_id))

        self._data_flows[data_flow_id].parent = None
        return self._data_flows.pop(data_flow_id)
1237905
def _del_process(self, dwProcessId):
        
        try:
            aProcess = self.__processDict[dwProcessId]
            del self.__processDict[dwProcessId]
        except KeyError:
            aProcess = None
            msg = "Unknown process ID %d" % dwProcessId
            warnings.warn(msg, RuntimeWarning)
        if aProcess:
            aProcess.clear()
194582
def add_new_data_port(self):
        """"""
        try:
            new_data_port_ids = gui_helper_state_machine.add_data_port_to_selected_states('OUTPUT', int, [self.model])
            if new_data_port_ids:
                self.select_entry(new_data_port_ids[self.model.state])
        except ValueError:
            pass
549989
def delete_instance_if_removed(self, port):
        """"""
        instance_type = self.get_instance_type(port)
        if not instance_type:
            return
        if not db_lib.instance_provisioned(port['device_id']):
            i_res = MechResource(port['device_id'], instance_type,
                                 a_const.DELETE)
            self.provision_queue.put(i_res)
1302969
def remove_nexusport_binding(port_id, vlan_id, vni, switch_ip, instance_id):
    """"""
    LOG.debug("remove_nexusport_binding() called")
    session = bc.get_writer_session()
    binding = _lookup_all_nexus_bindings(session=session,
                                         vlan_id=vlan_id,
                                         vni=vni,
                                         switch_ip=switch_ip,
                                         port_id=port_id,
                                         instance_id=instance_id)
    for bind in binding:
        session.delete(bind)
    session.flush()
    return binding
950003
def remove(self, cluster_id):
        
        cluster = self._storage.pop(cluster_id)
        cluster.cleanup()
546300
def remove_container(self, container_id, force=False):
        
        logger.info("removing container '%s' from filesystem", container_id)
        logger.debug("container_id = '%s'", container_id)
        self.d.remove_container(container_id, force=force)
1002488
def cmd_output_remove(self, args):
        ''''''
        device = args[0]
        for i in range(len(self.mpstate.mav_outputs)):
            conn = self.mpstate.mav_outputs[i]
            if str(i) == device or conn.address == device:
                print("Removing output %s" % conn.address)
                try:
                    mp_util.child_fd_list_add(conn.port.fileno())
                except Exception:
                    pass
                conn.close()
                self.mpstate.mav_outputs.pop(i)
                return
1226601
def remove(self, block_id):
        
        with self._mutex:
            entry = self._block_map[block_id]
            self._queue.remove(entry)