The list of all input ports belonging to this component that are
        connected to one or more other ports.
198967
def connected_inports(self):
        '''

        '''
        return [p for p in self.ports \
                if p.__class__.__name__ == 'DataInPort' and p.is_connected]
916081
def cmd_link_ports(self):
        ''''''
        ports = mavutil.auto_detect_serial(preferred_list=['*FTDI*',"*Arduino_Mega_2560*", "*3D_Robotics*", "*USB_to_UART*", '*PX4*', '*FMU*'])
        for p in ports:
            print("%s : %s : %s" % (p.device, p.description, p.hwid))
1373526
def find_biconnected_components_as_subgraphs(graph):
    """"""
    list_of_graphs = []

    list_of_components = find_biconnected_components(graph)
    for edge_list in list_of_components:
        subgraph = get_subgraph_from_edge_list(graph, edge_list)
        list_of_graphs.append(subgraph)

    return list_of_graphs
176312
def p_instance_ports_list(self, p):
        ''
        p[0] = p[1] + (p[3],)
        p.set_lineno(0, p.lineno(1))
1019436
def _load_input_data_port_models(self):
        """"""
        if not self.state_copy_initialized:
            return
        self.input_data_ports = []
        for input_data_port_m in self.state_copy.input_data_ports:
            new_ip_m = deepcopy(input_data_port_m)
            new_ip_m.parent = self
            new_ip_m.data_port = input_data_port_m.data_port
            self.input_data_ports.append(new_ip_m)
512217
def get_components(self) -> List:
        """"""
        return [component for component in self.component_manager._components + self.component_manager._managers]
527058
def paramtypes(self):
        
        for m in [p[1] for p in self.ports]:
            for p in [p[1] for p in m]:
                for pd in p:
                    if pd[1] in self.params:
                        continue
                    item = (pd[1], pd[1].resolve())
                    self.params.append(item)
677650
def connected_svcports(self):
        '''

        '''
        return [p for p in self.ports \
                if p.__class__.__name__ == 'CorbaPort' and p.is_connected]
1062337
def ports(self) -> dict:
        """"""
        return {
            param: self[param].raw
            for param in self
            if param.startswith(IOPORT)
        }
1257469
def devices(self):
        
        devices = []
        count = self.lib.tdGetNumberOfDevices()
        for i in range(count):
            device = DeviceFactory(self.lib.tdGetDeviceId(i), lib=self.lib)
            devices.append(device)
        return devices
1141009
def _load_input_data_port_models(self):
        
        self.input_data_ports = []
        for input_data_port in self.state.input_data_ports.values():
            self._add_model(self.input_data_ports, input_data_port, DataPortModel)
345085
def find_bound_ports(self, ports):
        """"""
        bound = []
        for port in ports:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            try:
                s.bind((port.ip if port.ip is not NotSpecified else "127.0.0.1", port.host_port))
            except socket.error as error:
                bound.append(port.host_port)
            finally:
                s.close()

        if bound:
            raise AlreadyBoundPorts(ports=bound)
1305407
def source_components(self):
        
        raw_sccs = self._component_graph()

        # Construct a dictionary mapping each vertex to the root of its scc.
        vertex_to_root = self.vertex_dict()

        # And keep track of which SCCs have incoming edges.
        non_sources = self.vertex_set()

        # Build maps from vertices to roots, and identify the sccs that *are*
        # reachable from other components.
        for scc in raw_sccs:
            root = scc[0][1]
            for item_type, w in scc:
                if item_type == 'VERTEX':
                    vertex_to_root[w] = root
                elif item_type == 'EDGE':
                    non_sources.add(vertex_to_root[w])

        sccs = []
        for raw_scc in raw_sccs:
            root = raw_scc[0][1]
            if root not in non_sources:
                sccs.append([v for vtype, v in raw_scc if vtype == 'VERTEX'])

        return [self.full_subgraph(scc) for scc in sccs]
873443
def component_list(self):
	
		
		
		comp_list = []
		self.__component_list(self.component(None), comp_list)
		return sorted(comp_list)
609315
private List<String> getImportComponents( Component component ) {

		List<String> result = new ArrayList<> ();
		Map<String,Boolean> map = ComponentHelpers.findComponentDependenciesFor( component );
		for( Map.Entry<String,Boolean> entry : map.entrySet()) {
			String s = applyLink( entry.getKey(), entry.getKey());
			s += entry.getValue() ? this.messages.get( "optional" ) : this.messages.get( "required" ); //$NON-NLS-1$ //$NON-NLS-2$
			result.add( s );
		}

		return result;
	}
1343755
def all_ports(self):
        
        from mbuild.port import Port
        return [successor for successor in self.successors()
                if isinstance(successor, Port)]
801356
def calculate_part_visibility(self, ports):
        # type: (APortMap) -> None
        
        # Calculate a lookup of Source Port connected_value to part_name
        source_port_lookup = {}
        for part_name, port_infos in SourcePortInfo.filter_parts(ports).items():
            for port_info in port_infos:
                source_port_lookup[port_info.connected_value] = (
                    part_name, port_info.port)
        # Look through all the Sink Ports, and set both ends of the
        # connection to visible if they aren't specified
        for part_name, port_infos in SinkPortInfo.filter_parts(
                ports).items():
            for port_info in port_infos:
                if port_info.value != port_info.disconnected_value:
                    conn_part, port = source_port_lookup.get(
                        port_info.value, (None, None))
                    if conn_part and port == port_info.port:
                        if conn_part not in self.part_visibility:
                            self.part_visibility[conn_part] = True
                        if part_name not in self.part_visibility:
                            self.part_visibility[part_name] = True