fusor.models

Model for FUSOR classes

class fusor.models.AbstractFusion(**data)

Define AbstractFusion 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.

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

viccNomenclature: Optional[Annotated[str]]

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.AnchoredReads(**data)

Define AnchoredReads class

This class can be used to report the number of reads that span the fusion junction. This is used at the TranscriptSegment level, as it indicates the transcript where the longer segment of the read is found

reads: int

type: Literal[<FUSORTypes.ANCHORED_READS: 'AnchoredReads'>]

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]]

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]

contig: Optional[ContigSequence]

readData: Optional[ReadData]

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

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

class fusor.models.BaseModelForbidExtra(**data)

Base Pydantic model class with extra values forbidden.

class fusor.models.BaseStructuralElement(**data)

Define BaseStructuralElement class.

type: StructuralElementType

class fusor.models.BreakpointCoverage(**data)

Define BreakpointCoverage class.

This class models breakpoint coverage, or the number of fragments that are retained near the breakpoint for a fusion partner

fragmentCoverage: int

type: Literal[<FUSORTypes.BREAKPOINT_COVERAGE: 'BreakpointCoverage'>]

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.

civicMolecularProfiles: Optional[list[MolecularProfile]]

criticalFunctionalDomains: Optional[list[FunctionalDomain]]

moaAssertion: Optional[dict]

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

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

class fusor.models.ContigSequence(**data)

Define ContigSequence class.

This class models the assembled contig sequence that supports the reported fusion event

contig: Annotated[str]

type: Literal[<FUSORTypes.CONTIG_SEQUENCE: 'ContigSequence'>]

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.

ANCHORED_READS = 'AnchoredReads'

ASSAYED_FUSION = 'AssayedFusion'

BREAKPOINT_COVERAGE = 'BreakpointCoverage'

CATEGORICAL_FUSION = 'CategoricalFusion'

CAUSATIVE_EVENT = 'CausativeEvent'

CONTIG_SEQUENCE = 'ContigSequence'

FUNCTIONAL_DOMAIN = 'FunctionalDomain'

GENE_ELEMENT = 'GeneElement'

LINKER_SEQUENCE_ELEMENT = 'LinkerSequenceElement'

MULTIPLE_POSSIBLE_GENES_ELEMENT = 'MultiplePossibleGenesElement'

READ_DATA = 'ReadData'

REGULATORY_ELEMENT = 'RegulatoryElement'

SPANNING_READS = 'SpanningReads'

SPLIT_READS = 'SplitReads'

TEMPLATED_SEQUENCE_ELEMENT = 'TemplatedSequenceElement'

TRANSCRIPT_SEGMENT_ELEMENT = 'TranscriptSegmentElement'

UNKNOWN_GENE_ELEMENT = 'UnknownGeneElement'

class fusor.models.FunctionalDomain(**data)

Define FunctionalDomain class

associatedGene: MappableConcept

id: Optional[Annotated[str]]

label: Optional[Annotated[str]]

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: MappableConcept

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

class fusor.models.LinkerElement(**data)

Define LinkerElement class (linker sequence)

linkerSequence: LiteralSequenceExpression

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.

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

class fusor.models.ReadData(**data)

Define ReadData class.

This class is used at the AssayedFusion level when a fusion caller reports metadata describing sequencing reads for the fusion event

spanning: Optional[SpanningReads]

split: Optional[SplitReads]

type: Literal[<FUSORTypes.READ_DATA: 'ReadData'>]

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[MappableConcept]

classmethod ensure_min_values(values)

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

featureId: Optional[str]

featureLocation: Optional[SequenceLocation]

regulatoryClass: RegulatoryClass

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

class fusor.models.SpanningReads(**data)

Define SpanningReads class.

This class models the number of pairs of reads that support the reported fusion event

spanningReads: int

type: Literal[<FUSORTypes.SPANNING_READS: 'SpanningReads'>]

class fusor.models.SplitReads(**data)

Define SplitReads class.

This class models the number of reads that cover the junction bewteen the detected partners in the fusion

splitReads: int

type: Literal[<FUSORTypes.SPLIT_READS: 'SplitReads'>]

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 TemplatedSequenceElement class.

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

region: SequenceLocation

strand: Strand

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

class fusor.models.TranscriptSegmentElement(**data)

Define TranscriptSegmentElement class

anchoredReads: Optional[AnchoredReads]

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

coverage: Optional[BreakpointCoverage]

elementGenomicEnd: Optional[SequenceLocation]

elementGenomicStart: Optional[SequenceLocation]

exonEnd: Optional[Annotated[int]]

exonEndOffset: Optional[Annotated[int]]

exonStart: Optional[Annotated[int]]

exonStartOffset: Optional[Annotated[int]]

gene: MappableConcept

strand: Strand

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.

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

fusor.models.save_fusions_cache(fusions_list, cache_name, cache_dir=None)

Save a list of translated fusions as a cache

Parameters:

• fusions_list (list[AssayedFusion | CategoricalFusion]) – A list of FUSOR-translated fusions

• cache_name (str) – The name for the resultant cached file

• cache_dir (Optional[Path]) – The location to store the cached file. If this parameter is not supplied, it will default to storing data in the FUSOR_DATA_DIR directory

Return type:

None