Returns a list of Build tuples for all elements in the build chain.

        This method allows insight into the runtime of each configuratio inside the build chain.
179140
def build_stats_for_chain(self, build_chain_id):
        
        json_form = self.__retrieve_as_json(self.build_chain_path % build_chain_id)
        builds = [{'build_id': build[u'id'], 'configuration_id': build[u'buildTypeId']} for build in json_form[u'build']]

        return [
            BuildStat(
                build['build_id'],
                build['configuration_id'],
                self.__build_duration_for_id(build['build_id']),
                self.__build_start_date_for_id(build['build_id']))
            for build in builds
        ]
943297
def _make_builder_configs():
  
  config_list = []
  for each_corruption in TYPE_LIST:
    for each_severity in range(1, 6):
      name_str = each_corruption + '_' + str(each_severity)
      version_str = '0.0.1'
      description_str = 'corruption type = ' + each_corruption + ', severity = '
      description_str += str(each_severity)
      config_list.append(
          Imagenet2012CorruptedConfig(
              name=name_str,
              version=version_str,
              description=description_str,
              corruption_type=each_corruption,
              severity=each_severity,
          ))
  return config_list
532142
def find_build_map(stack_builders):
    
    assert isinstance(stack_builders[-1], instrs.STORE_MAP)

    to_consume = 0
    for instr in reversed(stack_builders):
        if isinstance(instr, instrs.STORE_MAP):
            # NOTE: This branch should always be hit on the first iteration.
            to_consume += 1
        elif isinstance(instr, instrs.BUILD_MAP):
            to_consume -= instr.arg
            if to_consume <= 0:
                return instr
    else:
        raise DecompilationError(
            "Couldn't find BUILD_MAP for last element of %s." % stack_builders
        )
509445
public synchronized List<RunT> getBuilds(RangeSet rs) {
        List<RunT> builds = new LinkedList<>();

        for (Range r : rs.getRanges()) {
            for (RunT b = getNearestBuild(r.start); b!=null && b.getNumber()<r.end; b=b.getNextBuild()) {
                builds.add(b);
            }
        }

        return builds;
    }
778062
def build(self):
        
        keys = self._param_grid.keys()
        grid_values = self._param_grid.values()

        def to_key_value_pairs(keys, values):
            return [(key, key.typeConverter(value)) for key, value in zip(keys, values)]

        return [dict(to_key_value_pairs(keys, prod)) for prod in itertools.product(*grid_values)]
1187181
def _build_block_element_list(self):
        
        return sorted(
            [e for e in self.block_elements.values() if not e.virtual],
            key=lambda e: e.priority,
            reverse=True
        )
368141
def list_builds(self, field_selector=None, koji_task_id=None, running=None,
                    labels=None):
        

        if running:
            running_fs = ",".join(["status!={status}".format(status=status.capitalize())
                                  for status in BUILD_FINISHED_STATES])
            if not field_selector:
                field_selector = running_fs
            else:
                field_selector = ','.join([field_selector, running_fs])
        response = self.os.list_builds(field_selector=field_selector,
                                       koji_task_id=koji_task_id, labels=labels)
        serialized_response = response.json()
        build_list = []
        for build in serialized_response["items"]:
            build_list.append(BuildResponse(build, self))

        return build_list
391936
def items(self) -> Tuple[Tuple[str, "Package"], ...]:  # type: ignore
        
        item_dict = {
            name: self.build_dependencies.get(name) for name in self.build_dependencies
        }
        return tuple(item_dict.items())
535364
public List<FacesConfigComponentType<FacesConfigType<T>>> getAllComponent()
   {
      List<FacesConfigComponentType<FacesConfigType<T>>> list = new ArrayList<FacesConfigComponentType<FacesConfigType<T>>>();
      List<Node> nodeList = childNode.get("component");
      for(Node node: nodeList)
      {
         FacesConfigComponentType<FacesConfigType<T>>  type = new FacesConfigComponentTypeImpl<FacesConfigType<T>>(this, "component", childNode, node);
         list.add(type);
      }
      return list;
   }
590207
protected function getBuilds() {
        if (!$this->_builds) {
            $this->_builds = new BuildList($this->version, $this->solution['sid']);
        }

        return $this->_builds;
    }
293975
def build_parameters(self):
        
        param_bits = []
        for name in self.parameters:
            param_bits.extend(self.build_parameter_by_name(name) or [])
        return param_bits
1080868
def _build_all_dependencies(self):
        '''
        
        '''
        ret = {}
        for model, schema in six.iteritems(self._models()):
            dep_list = self._build_dependent_model_list(schema)
            ret[model] = dep_list
        return ret
964582
def list_running_builds(page_size=200, page_index=0, sort=""):
    
    content = list_running_builds_raw(page_size, page_index, sort)
    if content:
        return utils.format_json_list(content)
6349
def get_all_conversion_chains_from_type(self, from_type: Type[Any]) \
            -> Tuple[List[Converter], List[Converter], List[Converter]]:
        
        return self.get_all_conversion_chains(from_type=from_type)
58188
public static <E> List<E> buildList(Iterable<E> iterable) {
        return StreamSupport.stream(iterable.spliterator(), false)
                .collect(toList());
    }
971304
def getAllKws(self):
        
        kws_ele = []
        kws_bl = []
        for ele in self.all_elements:
            if ele == '_prefixstr' or ele == '_epics':
                continue
            elif self.getElementType(ele).lower() == u'beamline':
                kws_bl.append(ele)
            else:
                kws_ele.append(ele)

        return tuple((kws_ele, kws_bl))
134504
def build(self):
        

        result = {}

        for lambda_function in self._functions_to_build:

            LOG.info("Building resource '%s'", lambda_function.name)
            result[lambda_function.name] = self._build_function(lambda_function.name,
                                                                lambda_function.codeuri,
                                                                lambda_function.runtime)

        return result