Builds list of data products.
196911
def buildDPList(self):
        """"""
        updated = False
        dps = []
        itemlist = self.getItemDPList()
        # first remove all items marked for removal, in case their names clash with new or renamed items
        for item, dp in itemlist:
            item._policy = item._combobox_current_value[self.ColAction]
            if dp and item._policy == "remove":
                dp.remove_file()
                dp.remove_subproducts()
        # now, make list
        for item, dp in itemlist:
            if item._policy == "remove":
                continue
            # update renderer and comment
            render = item._combobox_current_value[self.ColRender]
            comment = str(item.text(self.ColComment))
            if render != dp.render:
                dp.render = render
                updated = True
            if comment != dp.comment:
                dp.comment = comment
                updated = True
            # archived DPs may need to be renamed, for new ones simply set the name
            if dp.archived:
                updated = updated or dp.rename(str(item.text(self.ColRename)))
            else:
                dp.set_policy(item._policy)
                dp.filename = str(item.text(self.ColRename))
            dps.append(dp)
        return dps, updated
1077066
def provide_data(self):
        """"""
        return [(k, tuple([self.batch_size] + list(v.shape[1:]))) for k, v in self.data]
1042713
def _create_product_map(self):
        """"""

        self._product_map = {}

        for dep in self._tile.dependencies:
            try:
                dep_tile = IOTile(os.path.join('build', 'deps', dep['unique_id']))
            except (ArgumentError, EnvironmentError):
                raise BuildError("Could not find required dependency", name=dep['name'])

            self._add_products(dep_tile)

        self._add_products(self._tile, show_all=True)
619015
protected function buildViewsData()
    {
        $this->viewsData = $this->configs + ['blogPosts' => array_reverse((array) $this->postsData)];

        $this->fileHandler->viewsData = $this->viewsData;

        $this->blogPostHandler->viewsData = $this->viewsData;
    }
234556
def build(self):
        '''
        '''

        X_factory, mX_factory, category_idx_store, term_idx_store, metadata_idx_store, y \
            = self._init_term_doc_matrix_variables()
        parse_pipeline = ParsePipelineFactory(self.get_nlp(),
                                              X_factory,
                                              mX_factory,
                                              category_idx_store,
                                              term_idx_store,
                                              metadata_idx_store,
                                              y,
                                              self)
        df = self._clean_and_filter_nulls_and_empties_from_dataframe()
        tdm = self._apply_pipeline_and_get_build_instance(X_factory,
                                                          mX_factory,
                                                          category_idx_store,
                                                          df,
                                                          parse_pipeline,
                                                          term_idx_store,
                                                          metadata_idx_store,
                                                          y)
        return tdm
646403
def list_build_configurations_for_product(id=None, name=None, page_size=200, page_index=0, sort="", q=""):
    
    data = list_build_configurations_for_product_raw(id, name, page_size, page_index, sort, q)
    if data:
        return utils.format_json_list(data)
1148446
function buildDocsList() {
  const packagesWithoutBuiltDocs = [
    'basic-component-mixins',
    'basic-web-components'
  ];
  const ary = allPackages.filter(item => {
    return packagesWithoutBuiltDocs.indexOf(item) < 0;
  }).map(item => {
    return {
      src: `packages/${item}/src/*.js`,
      dest: `packages/${item}/README.md`};
  });

  return ary.concat(buildMixinsDocsList());
}
391391
protected function build()
    {
        $operation = $this->buildOperation('ListProfiles');

        $merchantID = $this->document->createElement('merchantID', $this->merchantId);
        $operation->appendChild($merchantID);

        if ($this->customerId) {
            $xmlMPayTid = $this->document->createElement('customerID', $this->customerId);
            $operation->appendChild($xmlMPayTid);
        }

        if ($this->expiredBy) {
            $xmlMPayTid = $this->document->createElement('expiredBy', $this->expiredBy);
            $operation->appendChild($xmlMPayTid);
        }

        if ($this->begin) {
            $xmlMPayTid = $this->document->createElement('begin', $this->begin);
            $operation->appendChild($xmlMPayTid);
        }

        if ($this->size) {
            $xmlMPayTid = $this->document->createElement('size', $this->size);
            $operation->appendChild($xmlMPayTid);
        }
    }
42286
def builds(self):
        
        if self._builds is None:
            self._builds = BuildList(self._version, service_sid=self._solution['sid'], )
        return self._builds
1289842
def generate_repo_list(product_name=None, product_version=None, product_milestone=None):
    
    if not validate_input_parameters(product_name, product_version, product_milestone):
        sys.exit(1)
    product_version = pnc_api.product_versions.get_all(q="version=='"+ product_version + "';product.name=='"+product_name+"'")
    if not product_version.content:
        logging.error('Specified product version not found.')
        sys.exit(1)
    product_version_id = product_version.content[0].id
    milestone = pnc_api.product_milestones.get_all(q="version=='"+ product_milestone + "';productVersion.id=='"+str(product_version_id)+"'")
    if not milestone.content:
        logging.error('Specified milestone not found.')
        sys.exit(1)
    milestone_id = milestone.content[0].id
    builds = get_all_successful_builds(milestone_id)
    if not builds:
        logging.warning('No builds performed in the milestone.')
        return
    for build in builds:
        built_artifacts = get_all_artifacts(build.id)
        for artifact in built_artifacts:
            print(artifact.identifier)
16239
def create_data_dir():
    
    from django_productline.context import PRODUCT_CONTEXT
    if not os.path.exists(PRODUCT_CONTEXT.DATA_DIR):
        os.mkdir(PRODUCT_CONTEXT.DATA_DIR)
        print('*** Created DATA_DIR in %s' % PRODUCT_CONTEXT.DATA_DIR)
    else:
        print('...DATA_DIR already exists.')
226912
def _build_resource(self):
        """"""
        additions = [
            {
                "name": added.name,
                "type": added.record_type,
                "ttl": str(added.ttl),
                "rrdatas": added.rrdatas,
            }
            for added in self.additions
        ]

        deletions = [
            {
                "name": deleted.name,
                "type": deleted.record_type,
                "ttl": str(deleted.ttl),
                "rrdatas": deleted.rrdatas,
            }
            for deleted in self.deletions
        ]

        return {"additions": additions, "deletions": deletions}
132214
def list_datasets(self):
        
        def _row_gen(attributes):
            for attr in attributes.values():
                yield (attr.name, attr.display_name)

        return pd.DataFrame.from_records(
            _row_gen(self.datasets),
            columns=['name', 'display_name'])
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)]
15068
def list(self):
        
        mylist = []
        for prod in self.product_list:
            if self.purchasable(prod) and not self.entitled(prod):
                mylist.append(prod)
        return mylist
1150422
public function build()
    {
        $values = array( 'access'           => false,
                         'genres'           => false,
                         'publication_date' => false,
                         'title'            => true,
                         'keywords'         => true,
                         'stock_tickers'    => true
        );
        foreach ($values as $value => $isEscaped) {
            if ( ! is_null( $this->{$value} )) {
                $this->addChild( sprintf( 'news:%s', $value ), $this->{$value}, $isEscaped );
            }
        }
    }
1321715
def _build_opr_data(self, data, store):
        """"""
        return {
            "invoice_data": {
                "invoice": {
                    "total_amount": data.get("total_amount"),
                    "description": data.get("description")
                },
                "store": store.info
            },
            "opr_data": {
                "account_alias": data.get("account_alias")
            }
        }