The containers that are connected to the network, as a list of
        :py:class:`~docker.models.containers.Container` objects.
196598
def containers(self):
        
        return [
            self.client.containers.get(cid) for cid in
            (self.attrs.get('Containers') or {}).keys()
        ]
378166
def list_container_objects(self, container, prefix=None, delimiter=None):
        
        LOG.debug('list_container_objects() with %s is success.', self.driver)
        return self.driver.list_container_objects(container, prefix, delimiter)
980603
def interconnects(self):
        
        if not self.__interconnects:
            self.__interconnects = Interconnects(self.__connection)
        return self.__interconnects
1069084
public static List<Container> getRegisteredContainers() {
        CONTAINERS_LOCK.lock();
        try {
            return ImmutableList.copyOf(CONTAINERS.values());
        } finally {
            CONTAINERS_LOCK.unlock();
        }
    }
312622
def connections( self, cls = None ):
        
        scene = self.scene()
        if ( not scene ):
            return []
        
        if ( not cls ):
            cls = XNodeConnection
        
        output = []
        for item in scene.items():
            if ( not isinstance(item, cls) ):
                continue
            
            if ( item.inputNode() == self or item.outputNode() == self ):
                output.append(item)
        
        return output
1219456
def names_container(self):
        
        if not self.stream:
            return os.path.isdir(self.object_name)
        else:
            return False
1285638
def get_containers
      containers = { }

      @executor_pool.ps() do |id, mac, *cidrs|
        next if id == 'weave:expose'

        containers[id] = cidrs
      end

      containers
    end
1080229
def get_container_list(self) -> list:
        
        # Initialising empty list
        containers = []

        containers_list = self._client.containers.list()
        for c_list in containers_list:
            containers.append(c_list.short_id)
        return containers
792297
def containers
      if @containers.nil? && !info[:containers].nil?
        @containers = []
        info[:containers].each do |uri|
          @containers.push(client.containers.get_from_uri(uri))
        end
      end
      @containers
    end
1192325
def busy_connections(self):
        
        return [c for c in self.connections.values()
                if c.busy and not c.closed]
1153930
def objects(self):
        
        data = self._get_raw_objects()

        return PaginatedList.make_paginated_list(data, self._client, TaggedObjectProxy,
                                                 page_url=type(self).api_endpoint.format(**vars(self)))
112209
def connections(self):
        
        if not self.__connections:
            self.__connections = Connections(
                self.__connection)
        return self.__connections
545710
def ports(self):
        ''''''
        with self._mutex:
            if not self._ports:
                self._ports = [ports.parse_port(port, self) \
                               for port in self._obj.get_ports()]
        return self._ports
249132
def nodes(self):
        
        resource = sub_collection(
            self.get_relation('vss_container_node'), 
            VSSContainerNode) 
        resource._load_from_engine(self, 'nodes') 
        return resource
1368420
def get_containers(self):
        """"""
        permitted = lambda c: settings.container_permitted(c.name)
        return [c for c in self._get_containers() if permitted(c)]
82196
def all_as_list():
    '''
    
    '''
    as_dict = all_as_dict()
    containers = as_dict['Running'] + as_dict['Frozen'] + as_dict['Stopped'] 
    containers_list = []
    for i in containers:
        i = i.replace(' (auto)', '')
        containers_list.append(i)
    return containers_list
486879
def idle_connections(self):
        
        return [c for c in self.connections.values()
                if not c.busy and not c.closed]