alhambra.glues

Module Contents

Classes

Use	int([x]) -> integer
Glue
GlueFactory
SSGlue
DXGlue
GlueList	Abstract base class for generic types.

Functions

merge_items(→ Optional[T])
_ensure_glue_name(→ str | None)	Ensure the glue name uses *, not /, and is reasonable.

Attributes

T
GlueA
GlueB
glue_factory

alhambra.glues.T

alhambra.glues.GlueA

alhambra.glues.GlueB

class alhambra.glues.Use

Bases: int, enum.Enum

int([x]) -> integer int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating point numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by ‘+’ or ‘-’ and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal. >>> int(‘0b100’, base=0) 4

UNUSED = 0

NULL = 1

INPUT = 2

OUTPUT = 3

BOTH = 4

PERMANENT = 5

UNSET = 6

classmethod from_any(other: str | Use | int) → Use

invert() → Use

merge(other: Use) → Use

abstract __or__(other: Any) → Use

Return self|value.

abstract __ror__(other: Any) → Use

Return value|self.

alhambra.glues.merge_items(a: T | None, b: T | None) → T | None

alhambra.glues._ensure_glue_name(n: str | None) → str | None

Ensure the glue name uses *, not /, and is reasonable.

class alhambra.glues.Glue

abstract property etype: str

property type: str

property is_complement: bool

property complement: GlueA

name: str | None

note: str | None

use: Use

abstractstrength: int | None

The stickydesign type of the glue.

_into_complement()

copy() → T

ident() → str

basename() → str

update(other: Glue)

merge(other: Glue) → Glue

__or__(other: Glue) → Glue

__ior__(other: Glue)

__ror__(other: Glue) → Glue

__eq__(other: object) → bool

Return self==value.

to_dict() → dict[str, Any]

static from_dict(d: dict[str, Any]) → Glue

class alhambra.glues.GlueFactory

types: dict[str, Type[Glue]]

register(c: Type[Glue])

from_dict(d: str | dict[str, Any]) → Glue

alhambra.glues.glue_factory

class alhambra.glues.SSGlue(name: str | None = None, length: None | int | str | alhambra.seq.Seq = None, sequence: None | str | alhambra.seq.Seq = None, note: str | None = None, use: Use | None = None)

Bases: Glue

property dna_length: int

property sequence: alhambra.seq.Seq

property _shortdesc: str

etype: str = 'S'

_sequence: alhambra.seq.Seq

ident() → str

_into_complement()

update(other: Glue | str)

merge(other: Glue | str) → SSGlue

to_dict() → dict[str, Any]

class alhambra.glues.DXGlue(etype, name=None, length=None, sequence: alhambra.seq.Seq | str | None = None, fullseq=None, use=None, abstractstrength=None, note=None)

Bases: Glue

property fseq: str | None

property seq: str | None

property comp

The complement end sequences of the End, as a string.

etype: Literal[TD, DT]

fullseq: alhambra.seq.Seq

_into_complement()

merge(other: Glue) → DXGlue

__str__()

Return str(self).

class alhambra.glues.GlueList(initial: Iterable[T_NMI] = tuple())

Bases: Generic[GlueA], alhambra.classes.UpdateListD[GlueA]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

merge_complements() → None

merge_glue(g: GlueA) → GlueA

merge_glue_and_update_list(g: GlueA) → GlueA

abstract to_endarrays() → Any