fusor.models

Model for fusion class

class fusor.models.AbstractFusion(**data)

Define Fusion class

classmethod enforce_abc(values)

Ensure only subclasses can be instantiated.

classmethod enforce_element_quantities(values)

Ensure minimum # of elements, and require > 1 unique genes.

To validate the unique genes rule, we extract gene IDs from the elements that designate genes, and take the number of total elements. If there is only one unique gene ID, and there are no non-gene-defining elements (such as an unknown partner), then we raise an error.

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

readingFramePreserved: Optional[Annotated[bool]]

regulatoryElement: Optional[RegulatoryElement]

structure: list[BaseStructuralElement]

classmethod structure_ends(values)

Ensure start/end elements are of legal types and have fields required by their position.

type: FusionType

class fusor.models.AdditionalFields(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Define possible fields that can be added to Fusion object.

LOCATION_ID = 'location_id'

SEQUENCE_ID = 'sequence_id'

class fusor.models.Assay(**data)

Information pertaining to the assay used in identifying the fusion.

assayId: Optional[Annotated[str]]

assayName: Optional[Annotated[str]]

fusionDetection: Optional[Evidence]

methodUri: Optional[Annotated[str]]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

type: Literal['Assay']

class fusor.models.AssayedFusion(**data)

Assayed gene fusions from biological specimens are directly detected using RNA-based gene fusion assays, or alternatively may be inferred from genomic rearrangements detected by whole genome sequencing or by coarser-scale cytogenomic assays. Example: an EWSR1 fusion inferred from a breakapart FISH assay.

assay: Optional[Assay]

causativeEvent: Optional[CausativeEvent]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

structure: list[Annotated[TranscriptSegmentElement | GeneElement | TemplatedSequenceElement | LinkerElement | UnknownGeneElement]]

type: Literal[<FUSORTypes.ASSAYED_FUSION: 'AssayedFusion'>]

class fusor.models.BaseModelForbidExtra(**data)

Base Pydantic model class with extra values forbidden.

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

class fusor.models.BaseStructuralElement(**data)

Define base structural element class.

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

type: StructuralElementType

class fusor.models.CategoricalFusion(**data)

Categorical gene fusions are generalized concepts representing a class of fusions by their shared attributes, such as retained or lost regulatory elements and/or functional domains, and are typically curated from the biomedical literature for use in genomic knowledgebases.

criticalFunctionalDomains: Optional[list[FunctionalDomain]]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

structure: list[Annotated[TranscriptSegmentElement | GeneElement | TemplatedSequenceElement | LinkerElement | MultiplePossibleGenesElement]]

type: Literal[<FUSORTypes.CATEGORICAL_FUSION: 'CategoricalFusion'>]

class fusor.models.CausativeEvent(**data)

Define causative event information for a fusion.

The evaluation of a fusion may be influenced by the underlying mechanism that generated the fusion. Often this will be a DNA rearrangement, but it could also be a read-through or trans-splicing event.

eventDescription: Optional[Annotated[str]]

eventType: EventType

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

type: Literal[<FUSORTypes.CAUSATIVE_EVENT: 'CausativeEvent'>]

class fusor.models.DomainStatus(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Define possible statuses of functional domains.

LOST = 'lost'

PRESERVED = 'preserved'

class fusor.models.EventType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Permissible values for describing the underlying causative event driving an assayed fusion.

READ_THROUGH = 'read-through'

REARRANGEMENT = 'rearrangement'

TRANS_SPLICING = 'trans-splicing'

class fusor.models.Evidence(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Form of evidence supporting identification of the fusion.

INFERRED = 'inferred'

OBSERVED = 'observed'

class fusor.models.FUSORTypes(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Define FUSOR object type values.

ASSAYED_FUSION = 'AssayedFusion'

CATEGORICAL_FUSION = 'CategoricalFusion'

CAUSATIVE_EVENT = 'CausativeEvent'

FUNCTIONAL_DOMAIN = 'FunctionalDomain'

GENE_ELEMENT = 'GeneElement'

LINKER_SEQUENCE_ELEMENT = 'LinkerSequenceElement'

MULTIPLE_POSSIBLE_GENES_ELEMENT = 'MultiplePossibleGenesElement'

REGULATORY_ELEMENT = 'RegulatoryElement'

TEMPLATED_SEQUENCE_ELEMENT = 'TemplatedSequenceElement'

TRANSCRIPT_SEGMENT_ELEMENT = 'TranscriptSegmentElement'

UNKNOWN_GENE_ELEMENT = 'UnknownGeneElement'

class fusor.models.FunctionalDomain(**data)

Define FunctionalDomain class

associatedGene: Gene

id: Optional[Annotated[str]]

label: Optional[Annotated[str]]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

sequenceLocation: Optional[SequenceLocation]

status: DomainStatus

type: Literal[<FUSORTypes.FUNCTIONAL_DOMAIN: 'FunctionalDomain'>]

class fusor.models.FusionType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Specify possible Fusion types.

ASSAYED_FUSION = 'AssayedFusion'

CATEGORICAL_FUSION = 'CategoricalFusion'

classmethod values()

Provide all possible enum values.

Return type:

set

class fusor.models.GeneElement(**data)

Define Gene Element class.

gene: Gene

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

type: Literal[<FUSORTypes.GENE_ELEMENT: 'GeneElement'>]

class fusor.models.LinkerElement(**data)

Define Linker class (linker sequence)

linkerSequence: LiteralSequenceExpression

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

type: Literal[<FUSORTypes.LINKER_SEQUENCE_ELEMENT: 'LinkerSequenceElement'>]

class fusor.models.MultiplePossibleGenesElement(**data)

Define MultiplePossibleGenesElement class.

This is primarily intended to represent a partner in a categorical fusion, typifying generalizable characteristics of a class of fusions such as retained or lost regulatory elements and/or functional domains, often curated from biomedical literature for use in genomic knowledgebases. For example, EWSR1 rearrangements are often found in Ewing and Ewing-like small round cell sarcomas, regardless of the partner gene. We would associate this assertion with the fusion of EWSR1 with a MultiplePossibleGenesElement.

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

type: Literal[<FUSORTypes.MULTIPLE_POSSIBLE_GENES_ELEMENT: 'MultiplePossibleGenesElement'>]

class fusor.models.RegulatoryClass(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Define possible classes of Regulatory Elements.

Options are the possible values for /regulatory_class value property in the INSDC controlled vocabulary.

ATTENUATOR = 'attenuator'

CAAT_SIGNAL = 'caat_signal'

ENHANCER = 'enhancer'

ENHANCER_BLOCKING_ELEMENT = 'enhancer_blocking_element'

GC_SIGNAL = 'gc_signal'

IMPRINTING_CONTROL_REGION = 'imprinting_control_region'

INSULATOR = 'insulator'

LOCUS_CONTROL_REGION = 'locus_control_region'

MINUS_10_SIGNAL = 'minus_10_signal'

MINUS_35_SIGNAL = 'minus_35_signal'

OTHER = 'other'

POLYA_SIGNAL_SEQUENCE = 'polya_signal_sequence'

PROMOTER = 'promoter'

RESPONSE_ELEMENT = 'response_element'

RIBOSOME_BINDING_SITE = 'ribosome_binding_site'

RIBOSWITCH = 'riboswitch'

SILENCER = 'silencer'

TATA_BOX = 'tata_box'

TERMINATOR = 'terminator'

class fusor.models.RegulatoryElement(**data)

Define RegulatoryElement class.

featureId would ideally be constrained as a CURIE, but Encode, our preferred feature ID source, doesn’t currently have a registered CURIE structure for EH_ identifiers. Consequently, we permit any kind of free text.

associatedGene: Optional[Gene]

classmethod ensure_min_values(values)

Ensure that one of {featureId, featureLocation}, and/or associatedGene is set.

featureId: Optional[str]

featureLocation: Optional[SequenceLocation]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

regulatoryClass: RegulatoryClass

type: Literal[<FUSORTypes.REGULATORY_ELEMENT: 'RegulatoryElement'>]

class fusor.models.StructuralElementType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Define possible structural element type values.

GENE_ELEMENT = 'GeneElement'

LINKER_SEQUENCE_ELEMENT = 'LinkerSequenceElement'

MULTIPLE_POSSIBLE_GENES_ELEMENT = 'MultiplePossibleGenesElement'

TEMPLATED_SEQUENCE_ELEMENT = 'TemplatedSequenceElement'

TRANSCRIPT_SEGMENT_ELEMENT = 'TranscriptSegmentElement'

UNKNOWN_GENE_ELEMENT = 'UnknownGeneElement'

class fusor.models.TemplatedSequenceElement(**data)

Define Templated Sequence Element class.

A templated sequence is a contiguous genomic sequence found in the gene product.

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

region: SequenceLocation

strand: Strand

type: Literal[<FUSORTypes.TEMPLATED_SEQUENCE_ELEMENT: 'TemplatedSequenceElement'>]

class fusor.models.TranscriptSegmentElement(**data)

Define TranscriptSegment class

classmethod check_exons(values)

Check that at least one of {exonStart, exonEnd} is set. If set, check that the corresponding elementGenomic field is set. If not set, set corresponding offset to None

elementGenomicEnd: Optional[SequenceLocation]

elementGenomicStart: Optional[SequenceLocation]

exonEnd: Optional[Annotated[int]]

exonEndOffset: Optional[Annotated[int]]

exonStart: Optional[Annotated[int]]

exonStartOffset: Optional[Annotated[int]]

gene: Gene

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

transcript: Annotated[str]

type: Literal[<FUSORTypes.TRANSCRIPT_SEGMENT_ELEMENT: 'TranscriptSegmentElement'>]

class fusor.models.UnknownGeneElement(**data)

Define UnknownGene class.

This is primarily intended to represent a partner in the result of a fusion partner-agnostic assay, which identifies the absence of an expected gene. For example, a FISH break-apart probe may indicate rearrangement of an MLL gene, but by design, the test cannot provide the identity of the new partner. In this case, we would associate any clinical observations from this patient with the fusion of MLL with an UnknownGene element.

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

type: Literal[<FUSORTypes.UNKNOWN_GENE_ELEMENT: 'UnknownGeneElement'>]