Create a new product.

        Args:
          name: name of the new product.

        Returns:
          A new product instance.
11637
def new_product(self, name):
        
        n = self._product_cls(self, name, summary_cls=self._summary_cls)
        self.graph.add_node(n)
        self.products.append(n)
        return n
516128
def new_multigraph(self, name, data=None, **attr):
        
        self._init_graph(name, 'MultiGraph')
        mg = MultiGraph(self, name, data, **attr)
        self._graph_objs[name] = mg
        return mg
1283147
def create(name: str, *,
           validate: bool=None) -> snug.Query[Channel]:
    """"""
    return {'name': name, 'validate': validate}
1189019
def new(namespace, name, protected=False,
            attributes=dict(), api_url=fapi.PROD_API_ROOT):
        
        r = fapi.create_workspace(namespace, name, protected, attributes, api_url)
        fapi._check_response_code(r, 201)
        return Workspace(namespace, name, api_url)
100741
public static Requirement newInstance(String name)
    {
        Requirement requirement = new Requirement();
        requirement.setName(name);
        return requirement;
    }
472030
def create(self, name, **kwargs):
        """"""
        return self._write_op(self._create_nosync, name, **kwargs)
1325690
def new_tag(self, name: str, category: str=None) -> models.Tag:
        """"""
        new_tag = self.Tag(name=name, category=category)
        return new_tag
1196559
def create_instance(self, application, revision=None, environment=None, name=None, parameters=None, submodules=None,
                        destroyInterval=None, manifestVersion=None):
        
        from qubell.api.private.instance import Instance
        return Instance.new(self._router, application, revision, environment, name,
                            parameters, submodules, destroyInterval, manifestVersion=manifestVersion)
710204
def create_session(self, name=None):
        
        self.session = Session.create(self, name=name)
        return self.session
280716
def new_bundle(self, name: str, created_at: dt.datetime=None) -> models.Bundle:
        """"""
        new_bundle = self.Bundle(name=name, created_at=created_at)
        return new_bundle
649941
public static Runner newInstance(String name)
    {
        Runner runner = new Runner();
        runner.setName(name);
        
        return runner;
    }
116030
def new(self, *args, **kwargs):
        '''
'''
        return self.session().add(self.model(*args, **kwargs))
120207
def create(self, name):
        
        timer = metrics.Timer()
        timer.start()
        type = self.resolver.find(name)
        if type is None:
            raise TypeNotFound(name)
        if type.enum():
            result = sudsobject.Factory.object(name)
            for e, a in type.children():
                setattr(result, e.name, e.name)
        else:
            try:
                result = self.builder.build(type)
            except Exception, e:
                log.error("create '%s' failed", name, exc_info=True)
                raise BuildError(name, e)
        timer.stop()
        metrics.log.debug("%s created: %s", name, timer)
        return result
446929
def create(self, item, dry_run=None):
        """"""
        logger.debug('Creating new item. Item: {item} Path: {data_file}'.format(
            item=item,
            data_file=self.data_file
        ))

        items = load_file(self.client, self.bucket_name, self.data_file)
        items = append_item(self.namespace, self.version, item, items)
        save_file(self.client, self.bucket_name, self.data_file, items, dry_run=dry_run)

        return item
1022053
def create (self, name, *args):
        """"""
        tab  = None
        defn = self.get(name, None)
        if defn:
            tab = FSWTab(defn, *args)
        return tab
1004783
def create_namedlayer(self, name):
        
        namedlayer = self.get_or_create_element('sld', 'NamedLayer')
        namedlayer.Name = name
        return namedlayer
1146480
def createLabel(self, name):
        
        if self.findLabel(name):
            raise exception.LabelException('Label exists')
        node = _node.Label()
        node.name = name
        self._labels[node.id] = node # pylint: disable=protected-access
        return node