Create a report design based on an existing template.
        
        :param str name: Name of new report design
        :raises CreateElementFailed: failed to create template
        :rtype: ReportDesign
359765
def create_design(self, name):
        
        result = self.make_request(
            CreateElementFailed,
            resource='create_design',
            raw_result=True,
            method='create',
            params={'name': name})
    
        return ReportDesign(
            href=result.href, type=self.typeof, name=name)
143161
def create(element, element_id=nil, &block)
      element = initialize_element(element, element_id)
      style_and_context(element, element_id, &block)

      element
    end
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
1146841
def new(self, name):
        
        #XXX:dc: assert that the name is somewhat sane and follows python
        # naming conventions
        next_id = 0
        cls_name = '_'.join((name, next_id))
        with open(pjoin(self.migration_home, name), "w+") as new_migration:
            print >> new_migration, migration_tmpl.format(
                cls_name=cls_name, migration_name=name)
765035
private DOMNode getExistingTemplate(final String name) {

		try (final Tx tx = app.tx()) {

			return Importer.findSharedComponentByName(name);

		} catch (FrameworkException fex) {
			logger.warn("Unable to determine if template {} already exists, ignoring.", name);
		}

		return null;
	}
1327091
def create_item(self, name):
        
        elem = self.controlled_list.create_item(name)
        if elem:
            return TodoElementUX(parent=self, controlled_element=elem)
369260
def put_design(self, design_name, design, verbose=False):
    

    try:

      try:
        # check if there is a previous revision of the
        # specified design, if there is get the _rev
        # id from it and apply it to the new version
        existing = self.get_design(design_name)

        design = json.loads(design)

        if design.get("version") and existing.get("version") == design.get("version"):
          if verbose:
            print "No change in design... skipping update!"
          return

        design["_rev"] = existing["_rev"]
        design = json.dumps(design)
      except RESTException:
        pass

      r = requests.request(
        "PUT",
        "%s/%s/_design/%s" % (
          self.host,
          self.database_name,
          design_name
        ),
        auth=self.auth,
        data=design,
        headers={"content-type" : "application/json"}
      )

      return self.result(r.text)

    except:
      raise
51559
public static com.google.gwt.dom.client.Element createIFrameElement(String name) {

        return getDOMImpl().createIFrameElement(Document.get(), name);
    }
595078
def load(self, name, parent_path=None):
        
        if name not in self.templates:
            self.templates[name] = self._create_template(name)
        return self.templates[name]
1195039
public static QueryTemplate create(String name, Iterable<String> values, Charset charset) {
    return create(name, values, charset, CollectionFormat.EXPLODED);
  }
82854
def create(self, name, *args, **kwargs):
        
        resource_name = self._resource_name(name)
        log.info(
            "Creating {} '{}'...".format(self._model_name, resource_name))
        resource = self.collection.create(*args, name=resource_name, **kwargs)
        self._ids.add(resource.id)
        return resource
188284
def create(self, name: str, descriptor: str,
               code: CodeAttribute=None) -> Method:
        
        method = Method(self._cf)
        name = self._cf.constants.create_utf8(name)
        descriptor = self._cf.constants.create_utf8(descriptor)
        method._name_index = name.index
        method._descriptor_index = descriptor.index
        method.access_flags.acc_public = True

        if code is not None:
            method.attributes.create(CodeAttribute)

        self.append(method)
        return method
680688
def create_project(self, name, description):
        
        return self._create_item_response(
            self.data_service.create_project(name, description),
            Project)
742498
def create(context, name):
    

    result = tag.create(context, name=name)
    utils.format_output(result, context.format)
392269
def html_init(name):
    
    result = ""
    result += "<html>\n"
    result += "<head>\n"
    result += "<title>" + str(name) + "</title>\n"
    result += "</head>\n"
    result += "<body>\n"
    result += '<h1 style="border-bottom:1px solid ' \
              'black;text-align:center;">PyCM Report</h1>'
    return result
241243
def create_default_element(self, name):
        

        found = self.root.find(name)
        if found is not None:
            return found
        ele = ET.Element(name)
        self.root.append(ele)
        return ele
635751
def add_task(self, name=None, desc=None):
        
        # A name is required to create a task
        for k in self.get_tasks():
            if name in keys_of(k):
                raise ValueError('Task already exists')

        if name is not None:
            # desc can be None, so we can just append whatever we have
            self.grindstone['tasks'].append( {name: desc} )
        else:
            # Raising errors is good, and makes tests easy.
            raise ValueError('Tasks `name` cannot be None')