Create a new Sequence for the current project

        :returns: None
        :rtype: None
        :raises: None
344994
def prj_create_seq(self, *args, **kwargs):
        
        if not self.cur_prj:
            return
        seq = self.create_seq(project=self.cur_prj)
        if seq:
            seqdata = djitemdata.SequenceItemData(seq)
            treemodel.TreeItem(seqdata, self.prj_seq_model.root)
104515
def target_sequence(self):
        # type: () -> SeqRecord
        
        if self.cutter.is_3overhang():
            start, end = self._match.span(2)[0], self._match.span(3)[1]
        else:
            start, end = self._match.span(1)[0], self._match.span(2)[1]
        return add_as_source(self.record, (self.record << start)[end - start :])
563259
def create_project(self, name, client_id, budget = None, budget_by =
    	'none', notes = None, billable = True):
        ''''''
        project = {'project':{
            'name': name,
            'client_id': client_id,
            'budget_by': budget_by,
            'budget': budget,
            'notes': notes,
            'billable': billable,
        }}
        response = self.post_request('projects/', project, follow = True)
        if response:
            return Project(self, response['project'])
1045119
def create_dep(self, ):
        
        name = self.name_le.text()
        short = self.short_le.text()
        assetflag = self.asset_rb.isChecked()
        ordervalue = self.ordervalue_sb.value()
        desc = self.desc_pte.toPlainText()
        try:
            dep = djadapter.models.Department(name=name, short=short, assetflag=assetflag, ordervalue=ordervalue, description=desc)
            dep.save()
            for prj in self.projects:
                dep.projects.add(prj)
            self.dep = dep
            self.accept()
        except:
            log.exception("Could not create new department.")
305777
def add_sequence(tag, options={})
      add(s = Sequence.new(tag, options))
      s
    end
109983
def new(
    name,
    bucket,
    timeout,
    memory,
    description,
    subnet_ids,
    security_group_ids
):
    
    config = {}
    if timeout:
        config['timeout'] = timeout
    if memory:
        config['memory'] = memory
    if description:
        config['description'] = description
    if subnet_ids:
        config['subnet_ids'] = subnet_ids
    if security_group_ids:
        config['security_group_ids'] = security_group_ids

    lambder.create_project(name, bucket, config)
1279035
def new(self):
        # type: () -> None
        '''
        
        '''
        if self._initialized:
            raise pycdlibexception.PyCdlibInternalError('PL record already initialized!')

        self.parent_log_block_num = 0  # This will get set later

        self._initialized = True
234632
def create_project(self, project_path):
        
        shutil.copytree(self.project_path, project_path)

        self.update_file(project_path, 'requirements.txt', {
            'trionyx_version': trionyx.__version__
        })

        self.update_file(project_path, 'config/local_settings.py', {
            'secret_key': utils.random_string(32)
        })
385348
def _create_project(self, path):
        """"""
        self.open_project(path=path)
        self.setup_menu_actions()
        self.add_to_recent(path)
515023
def join(self, sequence):
        
        s = self.__class__()
        i = iter(sequence)
        try:
            s._append(Bits(next(i)))
            while True:
                n = next(i)
                s._append(self)
                s._append(Bits(n))
        except StopIteration:
            pass
        return s
1024396
def create_prj(self, ):
        
        name = self.name_le.text()
        short = self.short_le.text()
        path = self.path_le.text()
        semester = self.semester_le.text()
        try:
            prj = djadapter.models.Project(name=name, short=short, path=path, semester=semester)
            prj.save()
            self.project = prj
            self.accept()
        except:
            log.exception("Could not create new project")
317665
def create_node(self, name, project_id, node_id, *args, **kwargs):
        

        if node_id in self._nodes:
            return self._nodes[node_id]

        project = ProjectManager.instance().get_project(project_id)
        if node_id and isinstance(node_id, int):
            # old project
            with (yield from BaseManager._convert_lock):
                node_id = yield from self.convert_old_project(project, node_id, name)

        if not node_id:
            node_id = str(uuid4())

        node = self._NODE_CLASS(name, node_id, project, self, *args, **kwargs)
        if asyncio.iscoroutinefunction(node.create):
            yield from node.create()
        else:
            node.create()
        self._nodes[node.id] = node
        project.add_node(node)
        return node
646241
def create(self, project, slug, content, **attrs):
        
        attrs.update({'project': project, 'slug': slug, 'content': content})
        return self._new_resource(payload=attrs)
427957
def newBuild(self, requests):
        
        b = self.buildClass(requests)
        b.useProgress = self.useProgress
        b.workdir = self.workdir
        b.setStepFactories(self.steps)
        return b
287269
def create(self):
        
        # Calls each of these methods in order.  _populate_from_lines and
        # _update_relations must be implemented in subclasses.
        self._init_tables()
        self._populate_from_lines(self.iterator)
        self._update_relations()
        self._finalize()
926327
def copy(self):
        
        new_prog = self.copy_everything_except_instructions()
        new_prog._instructions = self._instructions.copy()
        return new_prog
183810
def create_pipeline(self, name, description, **kwargs):
		'''
		'''
		#req sanity check
		if not (name and description):
			return requests.codes.bad_request, None

		kwargs.update({'name':name, 'description':description})

		new_pl = StreakPipeline(**kwargs)
		uri = '/'.join([
						self.api_uri,
						self.pipelines_suffix
						])
		code, r_data = self._req('put', uri, new_pl.to_dict())
		
		return code, r_data