Python Strand.strandSet方法代码示例

# 需要导入模块: from cadnano.strand import Strand [as 别名]
# 或者: from cadnano.strand.Strand import strandSet [as 别名]
 def isModelStrandSelected(self, strand: Strand) -> bool:
     ss = strand.strandSet()
     if ss in self._selection_dict:
         if strand in self._selection_dict[ss]:
             return True
         else:
             return False
     else:
         return False

# 需要导入模块: from cadnano.strand import Strand [as 别名]
# 或者: from cadnano.strand.Strand import strandSet [as 别名]
    def getSelectedStrandValue(self, strand: Strand) -> EndsSelected:
        """Strand is an object to look up
        it is pre-vetted to be in the dictionary

        Args:
            strand: ``Strand`` object in question

        Returns:
            Tuple of the end point selection
        """
        return self._selection_dict[strand.strandSet()][strand]

# 需要导入模块: from cadnano.strand import Strand [as 别名]
# 或者: from cadnano.strand.Strand import strandSet [as 别名]
    def addStrandToSelection(self, strand: Strand, value: EndsSelected):
        """ Add `Strand` object to Document selection

        Args:
            strand:
            value: of the form::

                (is low index selected, is high index selected)

        """
        ss = strand.strandSet()
        if ss in self._selection_dict:
            self._selection_dict[ss][strand] = value
        else:
            self._selection_dict[ss] = {strand: value}
        self._strand_selected_changed_dict[strand] = value

# 需要导入模块: from cadnano.strand import Strand [as 别名]
# 或者: from cadnano.strand.Strand import strandSet [as 别名]
    def __init__(self, strand_low: Strand,
                        strand_high: Strand,
                        priority_strand: Strand):
        super(MergeCommand, self).__init__("merge strands")
        # Store strands
        self._strand_low = strand_low
        self._strand_high = strand_high

        self._s_set = s_set = priority_strand.strandSet()
        # Store oligos
        self._new_oligo = priority_strand.oligo().shallowCopy()
        self._s_low_oligo = s_low_olg = strand_low.oligo()
        self._s_high_oligo = s_high_olg = strand_high.oligo()

        # self._s_set_idx = low_strandset_idx

        # update the new oligo length if it's not a loop
        if s_low_olg != s_high_olg:
            self._new_oligo._setLength(s_low_olg.length() + s_high_olg.length(),
                                       emit_signals=True)

        # Create the new_strand by copying the priority strand to
        # preserve its properties
        new_idxs = strand_low.lowIdx(), strand_high.highIdx()
        new_strand = strand_low.shallowCopy()
        new_strand.setIdxs(new_idxs)
        new_strand.setConnectionHigh(strand_high.connectionHigh())

        self._new_strand = new_strand
        # Update the oligo for things like its 5prime end and isCircular
        self._new_oligo._strandMergeUpdate(strand_low, strand_high, new_strand)

        # set the new sequence by concatenating the sequence properly
        if strand_low._sequence or strand_high._sequence:
            tL = strand_low.totalLength()
            tH = strand_high.totalLength()
            seqL = strand_low._sequence if strand_low._sequence else "".join([" " for i in range(tL)])
            seqH = strand_high._sequence if strand_high._sequence else "".join([" " for i in range(tH)])
            if new_strand.isForward():
                new_strand._sequence = seqL + seqH
            else:
                new_strand._sequence = seqH + seqL

# 需要导入模块: from cadnano.strand import Strand [as 别名]
# 或者: from cadnano.strand.Strand import strandSet [as 别名]
    def removeStrandFromSelection(self, strand: Strand) -> bool:
        """Remove ``Strand`` object from Document selection

        Args:
            strand:

        Returns:
            ``True`` if successful, ``False`` otherwise
        """
        ss = strand.strandSet()
        if ss in self._selection_dict:
            temp = self._selection_dict[ss]
            if strand in temp:
                del temp[strand]
                if len(temp) == 0:
                    del self._selection_dict[ss]
                self._strand_selected_changed_dict[strand] = (False, False)
                return True
            else:
                return False
        else:
            return False

# 需要导入模块: from cadnano.strand import Strand [as 别名]
# 或者: from cadnano.strand.Strand import strandSet [as 别名]
    def __init__(self, strand: Strand, base_idx: int, update_sequence: bool = True):
        super(SplitCommand, self).__init__("split strand")
        # Store inputs
        self._old_strand = strand
        # TODO possibly implement selection preserving
        # doc = strand.document()
        # self.was_selected = was_selected = doc.isModelStrandSelected(strand)
        # if was_selected:
        #     self.select_values = doc.getSelectedStrandValue(strand)
        # else:
        #     self.select_values = (None, None)

        old_sequence = strand._sequence
        is5to3 = strand.isForward()

        self._s_set = strand.strandSet()
        self._old_oligo = oligo = strand.oligo()
        # Create copies
        self.strand_low = strand_low = strand.shallowCopy()
        self.strand_high = strand_high = strand.shallowCopy()

        if oligo.isCircular():
            self._l_oligo = self._h_oligo = l_oligo = h_oligo = oligo.shallowCopy()
        else:
            self._l_oligo = l_oligo = oligo.shallowCopy()
            self._h_oligo = h_oligo = oligo.shallowCopy()

        color_list = pathstyles.STAP_COLORS

        # Determine oligo retention based on strand priority
        if is5to3:  # strand_low has priority
            i_new_low = base_idx
            color_low = oligo.getColor()
            color_high = random.choice(color_list)
            olg5p, olg3p = l_oligo, h_oligo
            std5p, std3p = strand_low, strand_high
        else:  # strand_high has priority
            i_new_low = base_idx - 1
            color_low = random.choice(color_list)
            color_high = oligo.getColor()
            olg5p, olg3p = h_oligo, l_oligo
            std5p, std3p = strand_high, strand_low
        # this is for updating a connected xover view object
        # there is only ever one xover a strand is in charge of
        self._strand3p = std3p
        self._strand5p = std5p

        # Update strand connectivity
        strand_low.setConnectionHigh(None)
        strand_high.setConnectionLow(None)

        # Resize strands and update decorators
        strand_low.setIdxs((strand.lowIdx(), i_new_low))
        strand_high.setIdxs((i_new_low + 1, strand.highIdx()))

        # Update the oligo for things like its 5prime end and isCircular
        olg5p._strandSplitUpdate(std5p, std3p, olg3p, strand)

        if not oligo.isCircular():
            # Update the oligo color if necessary
            l_oligo._setColor(color_low)
            h_oligo._setColor(color_high)
            # settle the oligo length
            length = 0
            for strand in std3p.generator3pStrand():
                length += strand.totalLength()
            # end for
            olg5p._setLength(olg5p.length() - length, emit_signals=True)
            olg3p._setLength(length, emit_signals=True)
        # end if

        if update_sequence and old_sequence:
            if is5to3:  # strand_low has priority
                tL = strand_low.totalLength()
                strand_low._sequence = old_sequence[0:tL]
                strand_high._sequence = old_sequence[tL:]
            else:
                tH = strand_high.totalLength()
                strand_high._sequence = old_sequence[0:tH]
                strand_low._sequence = old_sequence[tH:]