Addition of a new checksum for circular DNA with one strand input (ccseguid)

[gyorgy5635]

Quite often during plasmid design a single strand is edited. I would be convenient to generate a new cheksum (e.g., ccseguid - circular check SEGUID) based on the single strand only. The _manip.py could generate the reverse complement of the DNA sequence (e.g., ReverseComplementDNA in C# implementation). The ccseguid method could take the DNA sequence, convert all characters to upper case, remove all characters not in ['AGCT'], generate the reverse complement, and use the cdseguid to generate the cheksum.

[HenrikBengtsson]

Let's discuss before moving forward with this. We made a fundamental decision on the design and API that says that the functions should automate as little as ever possible. Using this philosophy, it was straightforward to drop automatic conversion between upper and lower case symbols, which in turn allowed us to support a richer set of alphabets. It also helps to make it clear what the true identity and the limitations of the SEGUID v2 API is.

Instead, the idea is that such end-user utility features should be implemented in higher-level APIs outside of the core SEGUID V2 API, e.g. GUIs and pydna.

I'm inclined to argue that your proposal falls under the latter, but let's discuss. Point is that we should be conservative so we don't regret something later on.

[nicolazilio]

@HenrikBengtsson, I would also be interested in something like this.

We have a database where we store plasmid information. The maps are store as separate files.

I am looking for a way to know whether the same plasmid sequence appears twice without having to look through all sequence. Would ccseguid be required? Or is csseguid sufficient for this?

Thank you!

[BjornFJohansson]

@nicolazilio Hi and thank you for your interest in the SEGUID v2 checksums.It sounds like cdseguid would work for you since your sequences are both circular and double stranded.

cdseguid will give a unique checksum for a plasmid regardless of how the sequence is presented. You can choose any origin and / or the complementary sequence, so it could be used to find duplicates in a plasmid database.

[nicolazilio]

@BjornFJohansson, thank you for the tip. Then you would simply address the issue that the two strands of a plasmid should always be identical by simply passing both to cdseguid, that is the fwd and the rev (= reverse complement)?

[BjornFJohansson]

@nicolazilio No that happens automatically. The algorithm looks at both strands (one is inferred from the other), finds the minimal rotation of either strands and selects the smallest one of those. The checksum is then calculated on the selected data. An assumption is correct bese pairing between the strands.

[nicolazilio]

@BjornFJohansson, thank you for the clarification. Then I am even more confused, looking at these lines

seguid-python/src/seguid/_chksum.py

Lines 242 to 245 in e00bccf

	assert watson, "Watson sequence must not be empty"
	assert crick, "Crick sequence must not be empty"
	assert len(watson) == len(crick)
	assert_complementary(watson, crick, alphabet=alphabet)

, one would assume that both strands have to be explicitly passed to cdseguid. Not a problem like, creating the reverse complement with Biopython is easy enough.

[HenrikBengtsson]

I think @BjornFJohansson misunderstood your question. Yes, both strands need to be specified. That is by design of the seguid package - it's a minimal package with zero "hand-holding". There are reasons for this decision.

For example, in early versions of the implementation there were attempts to automatically support upper and lower case DNA letters, where lower case acgt would automatically be coerce to upper-case ACGT. This sounded all good and user-friendly, but then we realized it would risk letting mistakes pass through unnoticed, e.g. someone would enter:

ldseguid("TTGmGCAA", "TTGC1CAA", alphabet = "{DNA}")

when they meant:

ldseguid("TTGmGCAA", "TTGC1CAA", alphabet = "{DNA},m1,h2,f3,c4")

By being 100% strict on the input, we can detect mistakes.

For the similar reasons, by requiring both strands to be specified when using cdseguid(), we can protect against input mistakes. Yes, it would be convenient if one could specify, say,

cdseguid("GATTACA", "*")

or

cdseguid("*", "TGTAATC")

and have then automatically resolve to:

cdseguid("GATTACA", "TGTAATC")

But, by requiring both, we can lower the risk for input mistakes. It also avoids opening up the floor for exactly what else should be automated. So, by staying conservative and requiring everything being specified with zero "magic" makes it easy to provide a robust, stable API. As soon as we open up for bells'n'whistles the API becomes more complicated for us as maintainers - and there is a risk we open something up that we regret later.

For now, it's best to use, say, pydna - something like:

from pydna.dseq import Dseq
from seguid import cdseguid

watson = "GATTACA"
crick = Dseq(watson).rc()
checksum = cdseguid(watson, crick)

[BjornFJohansson]

@nicolazilio Sorry I responded perhaps too quickly above.

You can use Pydna like this:

from pydna.dseqrecord import Dseqrecord
dsr_c = Dseqrecord("GATTACA", circular=True)
print(dsr_c.seguid())
# cdseguid=z7GBDOjQuqwVpDiiC_CEJkmOKZo

Dseqrecord is a subclass of the BioPython SeqRecord that handles double stranded sequences by the Dseq class which is a double stranded version of the Biopython Seq class.

Or using exclusively Biopython:

from Bio.Seq import Seq
from seguid import cdseguid

watson = Seq("GATTACA")

crick = watson.reverse_complement()

checksum = cdseguid(str(watson), str(crick))

assert checksum == "cdseguid=z7GBDOjQuqwVpDiiC_CEJkmOKZo"