gencodegenes 1.0.0__tar.gz → 1.0.2__tar.gz

gencodegenes-1.0.2/MANIFEST.in

@@ -0,0 +1,16 @@
+# gencodegenes code
+include MANIFEST.in
+include pyproject.toml
+include src/gencodegenes/*.cpp
+include src/gencodegenes/*.py
+include src/gencodegenes/*.pyx
+include src/gencodegenes/*.pxd
+include src/gencodegenes/data/rates.txt
+include src/*.h
+include src/*.cpp
+include src/gzstream/gzstream.C
+include src/gzstream/gzstream.h
+include data/*.txt
+
+# gencodegenes tests
+include tests/*.py

{gencodegenes-1.0.0 → gencodegenes-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gencodegenes
-Version: 1.0.0
+Version: 1.0.2
 Summary: Package to load genes from GENCODE GTF files
 Home-page: https://github.com/jeremymcrae/gencodegenes
 Author: Jeremy McRae

{gencodegenes-1.0.0 → gencodegenes-1.0.2}/setup.py

@@ -107,7 +107,7 @@ setup(name="gencodegenes",
     description='Package to load genes from GENCODE GTF files',
     long_description=io.open('README.md', encoding='utf-8').read(),
     long_description_content_type='text/markdown',
-    version="1.0.0",
+    version="1.0.2",
     author="Jeremy McRae",
     author_email="jeremy.mcrae@gmail.com",
     license="MIT",

gencodegenes-1.0.2/src/gencodegenes/gencode.pyx

@@ -0,0 +1,436 @@
+# cython: language_level=3, boundscheck=False, emit_linenums=True
+
+import bisect
+import logging
+from pathlib import Path
+
+from libcpp.algorithm cimport lower_bound, upper_bound
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+from libcpp.map cimport map
+
+from pyfaidx import Fasta
+
+from gencodegenes.transcript cimport Tx, Region, CDS_coords
+from gencodegenes.transcript import Transcript
+
+cdef extern from "gtf.h" namespace "gencode":
+    cdef struct GTFLine:
+        string chrom
+        string feature
+        int start
+        int end
+        string strand
+        string symbol
+        string tx_id
+        string transcript_type
+        int is_canonical
+        
+    GTFLine parse_gtfline(string line)
+
+cdef extern from "gencode.h" namespace "gencode":
+    cdef struct NamedTx:
+        string symbol
+        Tx tx
+        int is_canonical
+    
+    cdef struct GenePoint:
+        int pos
+        string symbol
+    
+    vector[NamedTx] open_gencode(string, bool)
+    bool CompFunc(const GenePoint &l, const GenePoint &r)
+    vector[string] _in_region(string chrom, int start, int end, 
+        map[string, vector[GenePoint]] & starts, map[string, vector[GenePoint]] & ends,
+        int max_window) except+
+
+cpdef _parse_gtfline(string line):
+    ''' python function for unit testing GTF parsing
+    '''
+    return parse_gtfline(line)
+
+cdef _convert_exons(vector[Region] exons):
+    ''' convert vector of exon Regions to list of lists
+    
+    We need exons and CDS as lists of lists for constructing the python 
+    Transcript object.
+    '''
+    return [[y.start, y.end] for y in exons]
+
+cpdef _open_gencode(gtf_path, coding_only=True):
+    ''' python function for unit testing loading transcripts from GTF
+    '''
+    cdef vector[NamedTx] _transcripts = open_gencode(gtf_path.encode('utf8'), coding_only)
+    
+    transcripts = []
+    for x in _transcripts:
+        tx = x.tx
+        chrom = tx.get_chrom().decode('utf8')
+        start = tx.get_start()
+        end = tx.get_end()
+        exons = _convert_exons(tx.get_exons())
+        cds = _convert_exons(tx.get_cds())
+        strand = chr(tx.get_strand())
+        tx_id = tx.get_name().decode('utf8')
+        transcript_type = tx.get_type().decode('utf8')
+        transcript = Transcript(tx_id, chrom, start, end, strand, transcript_type, exons, cds, offset=0)
+        transcripts.append((x.symbol.decode('utf8'), transcript, x.is_canonical))
+    return transcripts
+
+__genome_ = None
+
+cdef class Gene:
+    cdef string _symbol
+    cdef vector[Tx] _transcripts
+    cdef vector[int] _canonical
+    cdef str _chrom
+    cdef int _start, _end
+    def __cinit__(self, symbol):
+        if isinstance(symbol, str):
+            symbol = symbol.encode('utf8')
+        self._symbol = symbol
+        self.start = 999999999
+        self.end = -999999999
+    
+    cdef add_tx(self, Tx tx, int is_canonical):
+        self._transcripts.push_back(tx)
+        self._canonical.push_back(is_canonical)
+        self.chrom = tx.get_chrom().decode('utf8')
+        self.start = min(self.start, tx.get_start())
+        self.end = max(self.end, tx.get_end())
+    
+    def add_transcript(self, _tx):
+        ''' add a Transcript to the gene object
+        
+        This ends up coping the data from the Transcript object, rather than
+        reusing the Tx object contained in the Trnascript, but it's not too much
+        time wasted, so long as we don't do this millions of times.
+        '''
+        assert isinstance(_tx, Transcript)
+        # construct a new Tx obect by copying out the relevant data
+        cdef string tx_id = _tx.get_name().encode('utf8')
+        cdef string chrom = _tx.get_chrom().encode('utf8')
+        cdef int start = _tx.get_start()
+        cdef int end = _tx.get_end()
+        cdef char strand = ord(_tx.get_strand())
+        cdef string tx_type = _tx.get_type().encode('utf8')
+        cdef vector[vector[int]] exons
+        cdef vector[vector[int]] cds
+        cdef vector[int] exon
+        for x in _tx.get_exons():
+            exon = [x['start'], x['end']]
+            exons.push_back(exon)
+        for x in _tx.get_cds():
+            exon = [x['start'], x['end']]
+            cds.push_back(exon)
+        
+        cdef Tx tx = Tx(tx_id, chrom, start, end, strand, tx_type)
+        tx.set_exons(exons, cds)
+        tx.set_cds(cds)
+        
+        cdef string seq = _tx.get_genomic_sequence().encode('utf8')
+        cdef int offset = _tx.get_genomic_offset()
+        if len(seq) > 0:
+            if chr(strand) == '-':
+                _tx.reverse_complement(seq)
+                seq = _tx.reverse_complement(seq).encode('utf8')
+            tx.add_genomic_sequence(seq, offset)
+        self.add_tx(tx, False)
+    
+    def __repr__(self):
+        chrom = self.chrom
+        return f'Gene("{self.symbol}", {chrom}:{self.start}-{self.end})'
+    
+    @property
+    def symbol(self):
+        return self._symbol.decode('utf8')
+    
+    @property
+    def chrom(self):
+        return self._chrom
+    @chrom.setter
+    def chrom(self, value):
+        self._chrom = value
+    
+    @property
+    def start(self):
+        return self._start
+    @start.setter
+    def start(self, value):
+        self._start = value
+    
+    @property
+    def end(self):
+        return self._end
+    @end.setter
+    def end(self, value):
+        self._end = value
+    
+    @property
+    def strand(self):
+        if self._transcripts.size() > 0:
+            return chr(self._transcripts[0].get_strand())
+        raise IndexError('no transcripts in gene yet')
+    
+    cdef _convert_exons(self, vector[Region] exons):
+        ''' convert vector of exon Regions to list of lists
+        
+        We need exons and CDS as lists of lists for constructing the python 
+        Transcript object.
+        '''
+        return [[y.start, y.end] for y in exons]
+    
+    cdef _to_Transcript(self, Tx tx):
+        ''' construct Transcript (python object) from Tx (c++ object)
+        '''
+        offset = 5 if tx.get_genomic_offset() == 0 else tx.get_genomic_offset()
+        chrom = tx.get_chrom().decode('utf8')
+        start = tx.get_start()
+        end = tx.get_end()
+        exons = self._convert_exons(tx.get_exons())
+        cds = self._convert_exons(tx.get_cds())
+        seq = tx.get_genomic_sequence().decode('utf8')
+        if seq == '':
+            seq = None
+        if seq is None and __genome_ is not None:
+            seq = __genome_[chrom][start-1-offset:end-1+offset].seq.upper()
+        strand = chr(tx.get_strand())
+        if strand == '-' and seq is not None:
+            seq = tx.reverse_complement(seq.encode('utf8')).decode('utf8')
+        tx_id = tx.get_name().decode('utf8')
+        tx_type = tx.get_type().decode('utf8')
+        return Transcript(tx_id, chrom, start, end, strand, tx_type, exons, cds, seq, offset=offset)
+    
+    @property
+    def transcripts(self):
+        ''' get list of Transcripts for gene, with genomic DNA included
+        '''
+        return [self._to_Transcript(x) for x in self._transcripts]
+    
+    cdef int _cds_len(self, Tx tx):
+        ''' get length of coding sequence for a Tx object based transcript
+        '''
+        cdef CDS_coords coords = tx.get_coding_distance(tx.get_cds_end())
+        return coords.position + 1
+    
+    cdef Tx _max_by_cds(self, vector[Tx] transcripts) except *:
+        ''' get longest transcript by CDS length
+        '''
+        cdef Tx max_tx
+        length = 0
+        for tx in transcripts:
+            curr_len = self._cds_len(tx)
+            if curr_len > length:
+                length = curr_len
+                max_tx = tx
+        if length == 0:
+            raise ValueError('no coding transcripts')
+        return max_tx
+    
+    cdef int _exonic_len(self, Tx tx):
+        ''' get length of exonic sequence for a Tx object based transcript
+        '''
+        length = 0
+        for start, end in _convert_exons(tx.get_exons()):
+            length += abs(end - start) + 1
+        return length
+        # return sum(abs(x.end - x.start) + 1 for x in tx.get_exons())
+    
+    cdef Tx _max_by_exonic(self, vector[Tx] transcripts) except *:
+        ''' get longest transcript by CDS length
+        '''
+        cdef Tx max_tx
+        length = 0
+        for tx in transcripts:
+            curr_len = self._exonic_len(tx)
+            if curr_len > length:
+                length = curr_len
+                max_tx = tx
+        if length == 0:
+            raise ValueError('no exonic transcripts')
+        return max_tx
+    
+    @property
+    def canonical(self):
+        ''' find the canonical transcript for a gene.
+        
+        Canonical is defined as:
+            - transcript with Ensembl_canonical tag (peferred)
+            - transcript with longest CDS tagged with appris_principal in the GTF
+            - if no appris_principal tags for any tx, use the tx with longest CDS
+            # TODO: for the last case, maybe check the protein coding subset first
+        
+        Occasionally there are multiple transcripts tagged as appris_principal
+        and with the same longest CDS, we use the first one of those.
+        '''
+        cdef vector[Tx] canonical
+        for i in range(self._transcripts.size()):
+            max_score = max(self._canonical)
+            if self._canonical[i] == max_score:
+                canonical.push_back(self._transcripts[i])
+        
+        if canonical.size() == 0:
+            canonical = self._transcripts
+        
+        cdef Tx max_tx
+        try:
+            max_tx = self._max_by_cds(canonical)
+        except ValueError:
+            max_tx = self._max_by_exonic(canonical)
+        
+        return self._to_Transcript(max_tx)
+    
+    def in_any_tx_cds(self, pos):
+        ''' find if a pos is in coding region of any transcript of a gene
+        '''
+        return any(tx.in_coding_region(pos) for tx in self._transcripts)
+    
+    def distance(self, chrom, pos):
+        ''' get distance to nearest boundary of a gene
+        '''
+        # sanatize the chromosome first
+        if self.chrom.startswith('chr') and not chrom.startswith('chr'):
+            chrom = f'chr{chrom}'
+        elif not self.chrom.startswith('chr') and chrom.startswith('chr'):
+            chrom = chrom[3:]
+        
+        if self.chrom != chrom:
+            return None
+        if self.start <= pos <= self.end:
+            return 0
+        return min(abs(self.start - pos), abs(self.end - pos))
+
+cdef class Gencode:
+    cdef dict genes
+    cdef map[string, vector[GenePoint]] starts, ends
+    def __cinit__(self, gencode=None, fasta=None, coding_only=True):
+        ''' initialise Gencode
+        
+        Args:
+            gencode: path to gencode annotations file
+            fasta: path to fasta for genome matching annotations build
+            coding: restrict to protein_coding only by default
+        '''
+        if gencode is not None and not Path(gencode).exists():
+            raise ValueError(f'cannot find gencode at: {gencode}')
+        if fasta is not None and not Path(fasta).exists():
+            raise ValueError(f'cannot find fasta at: {fasta}')
+        self.genes = {}
+        if fasta:
+            logging.info(f'opening genome fasta: {fasta}')
+            global __genome_
+            __genome_ = Fasta(str(fasta))
+        logging.info(f'opening gencode annotations: {gencode}')
+        cdef vector[NamedTx] transcripts
+        cdef Gene curr
+        if gencode is not None:
+            transcripts = open_gencode(str(gencode).encode('utf8'), coding_only)
+            for x in transcripts:
+                symbol = x.symbol.decode('utf8')
+                if symbol not in self.genes:
+                    self.genes[symbol] = Gene(symbol.encode('utf8'))
+                curr = self.genes[symbol]
+                curr.add_tx(x.tx, x.is_canonical)
+                self.genes[symbol] = curr
+        self._sort()
+    
+    def _sort(self):
+        ''' index by starts and ends, to speed finding genes in a region
+        '''
+        for symbol in self.genes:
+            gene = self.genes[symbol]
+            chrom = gene.chrom.encode('utf8')
+            symbol = symbol.encode('utf8')
+            
+            # ensure the chromosome is present
+            if self.starts.count(chrom) == 0:
+                self.starts[chrom] = []
+            if self.ends.count(chrom) == 0:
+                self.ends[chrom] = []
+            
+            self.starts[chrom].push_back(GenePoint(gene.start, symbol))
+            self.ends[chrom].push_back(GenePoint(gene.end, symbol))
+        
+        # sort start and end coords by position
+        for x, values in self.starts:
+            self.starts[x] = sorted(values, key=lambda x: x['pos'])
+        for x, values in self.ends:
+            self.ends[x] = sorted(values, key=lambda x: x['pos'])
+    
+    def __repr__(self):
+        return f'Gencode(n_genes={len(self)})'
+    def __len__(self):
+        return len(self.genes)
+    def __getitem__(self, symbol):
+        return self.genes[symbol]
+    def __iter__(self):
+        for x in self.genes:
+            yield x
+    
+    def add_gene(self, gene):
+        ''' add another gene to the Gencode object
+        '''
+        if gene.symbol not in self.genes:
+            self.genes[gene.symbol] = gene
+        self._sort()
+    
+    def nearest(self, str chrom, int pos):
+        ''' find the nearest gene to a genomic chrom, pos coordinate
+        '''
+        chrom = f'chr{chrom}' if not chrom.startswith('chr') else chrom
+        _chrom = chrom.encode('utf8')
+        
+        # first, account for any overlapping genespython
+        overlaps = self.in_region(chrom, pos-1, pos+1)  # NOTE: possibly fix?
+        if len(overlaps) > 0:
+            # if we have > 0 prioritise if the position is in the CDS
+            cds_overlaps = [x for x in overlaps if x.in_any_tx_cds(pos)]
+            if len(cds_overlaps) > 0:
+                overlaps = cds_overlaps
+            # prioritise the gene with longest CDS (in the canonical tx)
+            txs = [x.canonical for x in overlaps]
+            lengths = [x.get_coding_distance(x.get_cds_end())['pos'] for x in txs]
+            idx = lengths.index(max(lengths))
+            return overlaps[idx]
+        
+        # no overlaps observed, look for the nearest upstream or downstream gene
+        cdef GenePoint site = GenePoint(pos, b'A');
+        cdef unsigned int i = lower_bound(self.starts[_chrom].begin(), self.starts[_chrom].end(), site, &CompFunc) - self.starts[_chrom].begin()
+        cdef unsigned int j = upper_bound(self.ends[_chrom].begin(), self.ends[_chrom].begin(), site, &CompFunc) - self.ends[_chrom].begin()
+        
+        i = min(i, self.starts[_chrom].size() - 1)
+        j = min(j, self.starts[_chrom].size() - 1)
+        
+        downstream = self[self.starts[_chrom][i].symbol.decode('utf8')]
+        upstream = self[self.starts[_chrom][j].symbol.decode('utf8')]
+        
+        if upstream.distance(chrom, pos) <= downstream.distance(chrom, pos):
+            return upstream
+        else:
+            return downstream
+    
+    def in_region(self, str _chrom, int start, int end, int max_window=2500000):
+        ''' find genes within a genomic region
+        
+        Args:
+            chrom: chromosome to search on
+            start: start position of region
+            end: end position of region
+            max_window: some genes encapsulate the region, which means we have 
+                to account for gene lengths of up to 2.3 Mb in the human genome.
+                This permits extra search space in other organisms.
+        
+        Returns:
+            list of Gene objects
+        '''
+        symbols = _in_region(_chrom.encode('utf8'), start, end, self.starts,
+            self.ends, max_window)
+        return [self[x.decode('utf8')] for x in symbols]
+    
+    def __exit__(self):
+        ''' cleanup at exit
+        '''
+        global __genome_
+        __genome_.close()
+        __genome_ = None

gencodegenes-1.0.2/src/gencodegenes/transcript.pxd

@@ -0,0 +1,90 @@
+# cython: language_level=3, boundscheck=False
+'''
+Copyright (c) 2015 Genome Research Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+'''
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+cdef extern from "tx.h":
+    cdef cppclass Tx:
+        Tx(string, string, int, int, char, string) except +
+        Tx() except +
+        
+        void set_exons(vector[vector[int]], vector[vector[int]]) except +
+        void set_cds(vector[vector[int]]) except +
+        Region fix_cds_boundary(int) except +
+        
+        vector[Region] get_exons()
+        vector[Region] get_cds()
+        string get_name()
+        string get_chrom()
+        int get_start()
+        int get_end()
+        char get_strand()
+        string get_type()
+        int get_cds_start()
+        int get_cds_end()
+        
+        bool is_exonic(int)
+        int closest_exon_num(int)
+        Region get_closest_exon(int)
+        bool in_coding_region(int)
+        CDS_coords to_closest_exon(int, Region)
+        CDS_coords get_coding_distance(int) except +
+        
+        int get_position_on_chrom(int, int) except +
+        int get_codon_number_for_cds_position(int)
+        int get_position_within_codon(int)
+        void add_cds_sequence(string)
+        void add_genomic_sequence(string, int) except +
+        string get_cds_sequence()
+        string get_genomic_sequence()
+        int get_genomic_offset()
+        
+        string reverse_complement(string)
+        string get_centered_sequence(int, int) except +
+        string get_codon_sequence(int) except +
+        string get_seq_in_region(int, int) except +
+        string translate(string) except +
+        
+        Codon get_codon_info(int) except +
+        int get_boundary_distance(int) except +
+        string consequence(int, string, string) except +
+    
+    cdef struct CDS_coords:
+        int position
+        int offset
+    
+    cdef struct Region:
+        int start
+        int end
+    
+    cdef struct Codon:
+        int cds_pos
+        string codon_seq
+        int intra_codon
+        int codon_number
+        char initial_aa
+        int offset
+
+cdef class Transcript:
+    cdef Tx *thisptr # hold a C++ instance which we're wrapping

gencodegenes-1.0.2/src/gencodegenes/transcript.pyx

@@ -0,0 +1,378 @@
+# cython: language_level=3, boundscheck=False
+'''
+Copyright (c) 2015 Genome Research Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+'''
+
+from itertools import combinations
+
+cdef class Transcript:
+    def __cinit__(self, name, chrom, start, end, strand, 
+            transcript_type='protein_coding', exons=None, cds=None, sequence=None, 
+            offset=0):
+        ''' construct a Transcript object
+        
+        Args:
+            name: ID of the transcript
+            start: position in bp at 5' edge of transcript (on + strand)
+            end: position in bp at 3' edge of transcript (on + strand)
+            exons: list of tuples defining start and end positions of exons
+            cds: list of tuples defining start and end positions of CDS regions
+            sequence: DNA sequence of genome region of the transcript.
+            offset: how many base pairs the DNA sequence extends outwards
+        '''
+        
+        name = name.encode('utf8')
+        chrom = chrom.encode('utf8')
+        transcript_type = transcript_type.encode('utf8')
+        self.thisptr = new Tx(name, chrom, start, end, ord(strand), transcript_type)
+        
+        if exons is not None and cds is not None:
+            self.set_exons(exons, cds)
+            self.set_cds(cds)
+            
+            if sequence is not None:
+                self.add_genomic_sequence(sequence, offset)
+    
+    def __dealloc__(self):
+        del self.thisptr
+    
+    def __repr__(self):
+        
+        exons = [ (x['start'], x['end']) for x in self.get_exons() ]
+        cds = [ (x['start'], x['end']) for x in self.get_cds() ]
+        seq = self.get_genomic_sequence()
+        
+        if len(seq) > 40:
+            seq = seq[:20] + '...[{} bp]...'.format(len(seq) - 40) + seq[-20:]
+        
+        if exons == []:
+            exons = None
+        
+        if cds == []:
+            cds = None
+        
+        if seq == '':
+            seq = None
+        else:
+            seq = '"' + seq + '"'
+        
+        return f'Transcript(name="{self.get_name()}", chrom="{self.get_chrom()}", ' \
+            f'start={self.get_start()}, end={self.get_end()}, strand="{self.get_strand()}", ' \
+            f'transcript_type="{self.get_type()}", exons={exons}, cds={cds}, ' \
+            f'sequence={seq}, offset={self.get_genomic_offset()})'
+    
+    def __str__(self):
+        return self.__repr__()
+    
+    def __hash__(self):
+        return hash((self.thisptr.get_chrom(), self.thisptr.get_start(),
+            self.thisptr.get_end()))
+    
+    def __richcmp__(self, other, op):
+        
+        if op == 2:
+            return self.__hash__() == other.__hash__()
+        else:
+            err_msg = "op {0} isn't implemented yet".format(op)
+            raise NotImplementedError(err_msg)
+    
+    def set_exons(self, exon_ranges, cds_ranges):
+        ''' add exon ranges
+        
+        Args:
+            exon_ranges: a CDS position of the selected base.
+        '''
+        self.thisptr.set_exons(exon_ranges, cds_ranges)
+    
+    def get_overlaps(self, exon, regions):
+        ''' find all regions which overlap a given region
+        '''
+        return [ i for i, x in enumerate(regions) if
+            exon['start'] <= x['end'] and exon['end'] >= x['start'] ]
+    
+    def insert_region(self, coords, region):
+        ''' include a region into a list of regions
+        
+        To include a region, we have to check which pre-existing regions the new
+        region overlaps, so any overlaps can be merged into a single region.
+        
+        Args:
+            coords: list of {start: X, end: Y} dictionaries
+            region: dict of {'start': X, 'end': Y} positions
+        '''
+        indices = self.get_overlaps(region, coords)
+        overlaps = [ coords[i] for i in indices ]
+        start = min( x['start'] for x in overlaps + [region] )
+        end = max( x['end'] for x in overlaps + [region] )
+        
+        for i in sorted(indices, reverse=True):
+            del coords[i]
+        
+        return coords + [{'start': start, 'end': end}]
+    
+    def merge_coordinates(self, first, second):
+        ''' merge two sets of coordinates, to get the union of regions
+        
+        This uses an inefficient approach, looping over and over, but we won't
+        need to perform this often.
+        
+        Args:
+            first: list of {'start': x, 'end': y} dictionaries for first transcript
+            second: list of {'start': x, 'end': y} dictionaries for second transcript
+        
+        Returns:
+            list of [start, end] lists, sorted by position.
+        '''
+        coords = []
+        for a, b in combinations(first + second, 2):
+            if a['start'] <= b['end'] and a['end'] >= b['start']:
+                region = {'start': min(a['start'], b['start']),
+                    'end': max(a['end'], b['end'])}
+                a, b = region, region
+            
+            coords = self.insert_region(coords, a)
+            coords = self.insert_region(coords, b)
+        
+        return [ (x['start'], x['end']) for x in sorted(coords, key=lambda x: x['start']) ]
+    
+    def merge_genomic_seq(self, other):
+        ''' merge the genomic sequence from two transcripts
+        
+        We have two transcripts A, and B. We need to get the contiguous sequence
+        from the start of the first transcript on the chromosome to the end of
+        the second transcript. The transcripts may or may not overlap. There are
+        three scenarios we need to account for:
+        
+        
+        overlap without   A   =================
+        enveloping                           ================= B
+        
+        
+            overlap       A   ==============================
+        and envelop               ==================  B
+        
+        
+        no overlap        A  ===============
+                                               ===============  B
+        
+        I've called the transcript whose sequence is first along the chromosome
+        as 'lead', and the transcript whose sequence is last as 'lag', and the
+        converse as 'not_lead', and 'not_lag'. Note that in the envelope case,
+        the lead transcript can also be the lag transcript.
+        '''
+        
+        # make sure that the surrounding sequence is the same length in both
+        # transcripts.
+        # TODO: this could be worked around, by figuring the minimum offset length,
+        # TODO: then trimming the respective DNA offset sequences to that length.
+        assert self.get_genomic_offset() == other.get_genomic_offset()
+        
+        # figure out which transcripts hold the leading and lagging sections
+        lead, not_lead = self, other
+        if self.get_start() > other.get_start():
+            lead, not_lead = other, self
+        
+        lag, not_lag = self, other
+        if self.get_end() < other.get_end():
+            lag, not_lag = other, self
+        
+        lead_offset = lead.get_genomic_offset()
+        lead_gdna = lead.get_genomic_sequence()
+        initial = lead_gdna[:not_lead.get_start() - lead.get_start() + lead_offset]
+        
+        if self.get_start() <= other.get_end() and self.get_end() >= other.get_start():
+            intersect_start = not_lead.get_start() - lead.get_start() + lead_offset
+            intersect_end = not_lag.get_end() - lead.get_start() + lead_offset
+            intersect = lead_gdna[intersect_start:intersect_end]
+        else:
+            intersect = 'N' * (lag.get_start() - lead.get_end() - lead_offset * 2)
+        
+        lag_offset = lag.get_genomic_offset()
+        lag_gdna = lag.get_genomic_sequence()
+        
+        # some transcripts overlap, but some do not. We need to find the position
+        # where the lagging transcript takes over, which is either at the end of
+        # not lagging transcript, or the start of the lagging transcript,
+        # whichever is higher
+        pos = max(not_lag.get_end(), lag.get_start())
+        final = lag_gdna[pos - lag.get_start() + lead_offset:]
+        
+        return initial + intersect + final
+    
+    def __add__(self, other):
+        """ combine the coding sequences of two Transcript objects
+        
+        When we determine the sites for sampling, occasioally we want to
+        use sites from multiple alternative transcripts. We determine the sites
+        for each transcript in turn, but mask the sites that have been collected
+        in the preceeding transcripts. In order to be able to mask all previous
+        trabnscripts, we need to combine the coding sequence of the transcripts
+        as we move through them. This function performs the union of coding
+        sequence regions between different transcripts.
+        
+        We do this outside of the c++ class, so as to be able to set up a
+        Transcript object correctly.
+        
+        Args:
+            other: a transcript to be combined with the current object.
+        
+        Returns:
+            an altered instance of the class, where the coding sequence regions
+            are the union of the coding regions of two Transcript objects. This
+            disrupts the ability to get meaningingful sequence from the object,
+            so don't try to extract sequence from the returned object.
+        """
+        
+        # if we try transcript + None or None + transcript, return the original
+        # transcript, rather than raising an error.
+        if other is None:
+            return self
+        if self is None:
+            return other
+        
+        altered = Transcript('{}:{}'.format(self.get_name(), other.get_name()),
+            self.get_chrom(), min(self.get_start(), other.get_start()),
+            max(self.get_end(), other.get_end()), self.get_strand(), self.get_type())
+        
+        exons = self.merge_coordinates(self.get_exons(), other.get_exons())
+        cds = self.merge_coordinates(self.get_cds(), other.get_cds())
+        
+        altered.set_exons(exons, cds)
+        altered.set_cds(cds)
+        
+        if self.get_genomic_sequence() != "":
+            altered.add_genomic_sequence(self.merge_genomic_seq(other), self.get_genomic_offset())
+        
+        return altered
+    
+    def set_cds(self, cds_ranges):
+        ''' set CDS ranges
+        
+        Args:
+            cds_ranges: a CDS position of the selected base.
+        '''
+        
+        self.thisptr.set_cds(cds_ranges)
+    
+    def get_genomic_offset(self):
+        return self.thisptr.get_genomic_offset()
+    def get_exons(self):
+        return self.thisptr.get_exons()
+    def get_cds(self):
+        return self.thisptr.get_cds()
+    def get_name(self):
+        return self.thisptr.get_name().decode('utf8')
+    def get_chrom(self):
+        return self.thisptr.get_chrom().decode('utf8')
+    def get_type(self):
+        return self.thisptr.get_type().decode('utf8')
+    def get_start(self):
+        return self.thisptr.get_start()
+    def get_end(self):
+        return self.thisptr.get_end()
+    def get_strand(self):
+        return chr(self.thisptr.get_strand())
+    def get_cds_start(self):
+        return self.thisptr.get_cds_start()
+    def get_cds_end(self):
+        return self.thisptr.get_cds_end()
+    def fix_cds_boundary(self, pos):
+        return self.thisptr.fix_cds_boundary(pos)
+    
+    def in_exons(self, position):
+        ''' check if a site lies within the exon ranges
+        
+        Args:
+            position: an integer-based chromosome position.
+        '''
+        
+        return self.thisptr.is_exonic(position)
+    
+    def get_closest_exon(self, position):
+        ''' finds the positions of the exon closest to a position
+        '''
+        return self.thisptr.get_closest_exon(position)
+    
+    def in_coding_region(self, position):
+        return self.thisptr.in_coding_region(position)
+    
+    def get_coding_distance(self, pos):
+        ''' get distance to CDS start (and intronic offset)
+        '''
+        coords = self.thisptr.get_coding_distance(pos)
+        
+        return {'pos': coords.position, 'offset': coords.offset}
+    
+    def get_position_on_chrom(self, pos, offset=0):
+        return self.thisptr.get_position_on_chrom(pos, offset)
+    
+    def get_codon_number_for_cds_position(self, pos):
+        return self.thisptr.get_codon_number_for_cds_position(pos)
+    
+    def get_position_within_codon(self, pos):
+        return self.thisptr.get_position_within_codon(pos)
+    
+    def add_cds_sequence(self, text):
+        self.thisptr.add_cds_sequence(text.encode('utf8'))
+        
+    def get_cds_sequence(self):
+        return self.thisptr.get_cds_sequence().decode('utf8')
+    
+    def add_genomic_sequence(self, text, offset=0):
+        self.thisptr.add_genomic_sequence(text.encode('utf8'), offset)
+    
+    def get_genomic_sequence(self):
+        return self.thisptr.get_genomic_sequence().decode('utf8')
+    
+    def reverse_complement(self, text):
+        return self.thisptr.reverse_complement(text).decode('utf8')
+    
+    def get_centered_sequence(self, pos, length=3):
+        return self.thisptr.get_centered_sequence(pos, length).decode('utf8')
+    
+    def get_codon_sequence(self, pos):
+        return self.thisptr.get_codon_sequence(pos).decode('utf8')
+    
+    def translate(self, text):
+        return self.thisptr.translate(text.encode('utf8')).decode('utf8')
+    
+    def get_codon_info(self, pos):
+        codon = dict(self.thisptr.get_codon_info(pos))
+        
+        if codon['codon_number'] == -9999999:
+            codon['codon_number'] = None
+            codon['intra_codon'] = None
+            codon['codon_seq'] = None
+            codon['initial_aa'] = None
+        
+        if codon['codon_seq'] is not None:
+            codon['codon_seq'] = codon['codon_seq'].decode('utf8')
+        
+        if codon['initial_aa'] is not None:
+            codon['initial_aa'] = chr(codon['initial_aa'])
+        
+        return codon
+    
+    def get_boundary_distance(self, pos):
+        return self.thisptr.get_boundary_distance(pos)
+    
+    def consequence(self, pos, ref, alt):
+        cq = self.thisptr.consequence(pos, ref.encode('utf8'), alt.encode('utf8'))
+        return cq.decode('utf8')

{gencodegenes-1.0.0 → gencodegenes-1.0.2}/src/gencodegenes.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gencodegenes
-Version: 1.0.0
+Version: 1.0.2
 Summary: Package to load genes from GENCODE GTF files
 Home-page: https://github.com/jeremymcrae/gencodegenes
 Author: Jeremy McRae

{gencodegenes-1.0.0 → gencodegenes-1.0.2}/src/gencodegenes.egg-info/SOURCES.txt

@@ -11,7 +11,10 @@ src/tx.cpp
 src/tx.h
 src/gencodegenes/__init__.py
 src/gencodegenes/gencode.cpp
+src/gencodegenes/gencode.pyx
 src/gencodegenes/transcript.cpp
+src/gencodegenes/transcript.pxd
+src/gencodegenes/transcript.pyx
 src/gencodegenes.egg-info/PKG-INFO
 src/gencodegenes.egg-info/SOURCES.txt
 src/gencodegenes.egg-info/dependency_links.txt

gencodegenes-1.0.0/MANIFEST.in

@@ -1,15 +0,0 @@
-# genecodegenes code
-include MANIFEST.in
-include pyproject.toml
-include genecodegenes/*.cpp
-include genecodegenes/*.py
-include genecodegenes/*.pyx
-include genecodegenes/*.pxd
-include src/*.h
-include src/*.cpp
-include src/gzstream/gzstream.C
-include src/gzstream/gzstream.h
-include data/*.txt
-
-# genecodegenes tests
-include tests/*.py