gencodegenes 1.2.0__tar.gz → 1.2.2__tar.gz

{gencodegenes-1.2.0 → gencodegenes-1.2.2}/MANIFEST.in

@@ -10,8 +10,10 @@ include src/gencodegenes/py.typed
 include src/*.h
 include src/*.cpp
 
-include src/zlib/*.c
-include src/zlib/*.h
+graft src/zlib-ng
+prune src/zlib-ng/test
+prune src/zlib-ng/.github
+exclude src/zlib-ng/.git
 
 # gencodegenes tests
 include tests/*.py

{gencodegenes-1.2.0/src/gencodegenes.egg-info → gencodegenes-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gencodegenes
-Version: 1.2.0
+Version: 1.2.2
 Summary: Package to load genes from GENCODE GTF files
 Author-email: Jeremy McRae <jeremy.mcrae@gmail.com>
 License-Expression: MIT
@@ -75,8 +75,10 @@ tx.name         # transcript ID
 tx.chrom        # transcript chromosome
 tx.start        # transcript start (lowest position on chromosome)
 tx.end          # transcript end (highest position on chromosome)
-tx.cds_start    # CDS start position
-tx.cds_end      # CDS end position 
+tx.tss          # transcription start site (tx.end on the - strand)
+tx.cds_start    # CDS start position, in the direction of transcription (so
+                # the highest CDS position on the - strand)
+tx.cds_end      # CDS end position, in the direction of transcription
 tx.type         # transcript type e.g. protein_coding
 tx.strand       # strand (+ or -)
 tx.exons        # list of exon coordinates

{gencodegenes-1.2.0 → gencodegenes-1.2.2}/README.md

@@ -60,8 +60,10 @@ tx.name         # transcript ID
 tx.chrom        # transcript chromosome
 tx.start        # transcript start (lowest position on chromosome)
 tx.end          # transcript end (highest position on chromosome)
-tx.cds_start    # CDS start position
-tx.cds_end      # CDS end position 
+tx.tss          # transcription start site (tx.end on the - strand)
+tx.cds_start    # CDS start position, in the direction of transcription (so
+                # the highest CDS position on the - strand)
+tx.cds_end      # CDS end position, in the direction of transcription
 tx.type         # transcript type e.g. protein_coding
 tx.strand       # strand (+ or -)
 tx.exons        # list of exon coordinates

{gencodegenes-1.2.0 → gencodegenes-1.2.2}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["cython", "setuptools >= 77.0.0"]
+requires = ["cython", "setuptools >= 77.0.0", "cmake >= 3.14"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = 'gencodegenes'
-version = '1.2.0'
+version = '1.2.2'
 description = 'Package to load genes from GENCODE GTF files'
 readme = 'README.md'
 license = "MIT"

gencodegenes-1.2.2/setup.py

@@ -0,0 +1,88 @@
+
+import os
+import subprocess
+import sys
+import shutil
+
+from setuptools import setup, Extension
+from setuptools.command.build_ext import build_ext
+from Cython.Build import cythonize
+
+EXTRA_COMPILE_ARGS = []
+EXTRA_LINK_ARGS = []
+if sys.platform == "win32":
+    EXTRA_COMPILE_ARGS += ['/std:c++14']
+else:
+    EXTRA_COMPILE_ARGS += ['-std=c++11']
+    if sys.platform == "darwin":
+        EXTRA_COMPILE_ARGS += ["-stdlib=libc++"]
+        EXTRA_LINK_ARGS += ["-stdlib=libc++"]
+
+ZLIB_NG_DIR = os.path.abspath('src/zlib-ng')
+
+class build_ext_zlib_ng(build_ext):
+    ''' build zlib-ng as a static library (via cmake), before building extensions
+    
+    zlib-ng is built with its native API (zng_ prefixed functions), so it can't
+    clash with any system zlib loaded into the python process.
+    '''
+    def run(self):
+        build_dir = os.path.abspath(os.path.join(self.build_temp, 'zlib-ng'))
+        config = [
+            '-DCMAKE_BUILD_TYPE=Release',
+            '-DCMAKE_POSITION_INDEPENDENT_CODE=ON',
+            '-DBUILD_SHARED_LIBS=OFF',
+            '-DZLIB_COMPAT=OFF',
+            '-DWITH_GZFILEOP=ON',
+            '-DBUILD_TESTING=OFF',
+        ]
+        archflags = os.environ.get('ARCHFLAGS', '')
+        if sys.platform == 'darwin' and archflags:
+            # match the architectures requested for the extension (e.g. by cibuildwheel)
+            archs = ';'.join(archflags.split()[1::2])
+            config.append(f'-DCMAKE_OSX_ARCHITECTURES={archs}')
+        subprocess.check_call(['cmake', '-S', ZLIB_NG_DIR, '-B', build_dir] + config)
+        subprocess.check_call(['cmake', '--build', build_dir, '--config', 'Release',
+            '--parallel'])
+        
+        lib_dir = build_dir
+        lib = 'z-ng'
+        if sys.platform == 'win32':
+            lib_dir = os.path.join(build_dir, 'Release')
+            lib = 'zlibstatic-ng'
+        for ext in self.extensions:
+            if ext.name == 'gencodegenes.gencode':
+                ext.include_dirs.append(build_dir)
+                ext.library_dirs.append(lib_dir)
+                ext.libraries.append(lib)
+        super().run()
+
+extensions = [
+    Extension("gencodegenes.transcript",
+        extra_compile_args=EXTRA_COMPILE_ARGS,
+        extra_link_args=EXTRA_LINK_ARGS,
+        sources=[
+            "src/gencodegenes/transcript.pyx",
+            "src/tx.cpp"],
+        include_dirs=["src/"],
+        language="c++"),
+    Extension("gencodegenes.gencode",
+        extra_compile_args=EXTRA_COMPILE_ARGS,
+        extra_link_args=EXTRA_LINK_ARGS,
+        sources=[
+            "src/gencodegenes/gencode.pyx",
+            "src/gencode.cpp",
+            "src/gtf.cpp",
+            "src/tx.cpp"],
+        include_dirs=["src/"],
+        define_macros=[('WITH_GZFILEOP', None)],
+        language="c++"),
+    ]
+
+shutil.copy("src/tx.h", "src/gencodegenes/tx.h")
+
+setup(
+    package_dir={'': 'src'},
+    ext_modules=cythonize(extensions),
+    cmdclass={'build_ext': build_ext_zlib_ng},
+    )

gencodegenes-1.2.2/src/gencode.cpp

@@ -0,0 +1,302 @@
+
+#include <algorithm>
+#include <climits>
+#include <cstdlib>
+#include <deque>
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "gtf.h"
+#include "tx.h"
+#include "gencode.h"
+
+namespace gencode {
+
+// features collected for a transcript while loading the GTF, to construct a Tx
+struct TxInfo {
+    std::string name;
+    std::string chrom;
+    int start = 0;
+    int end = 0;
+    char strand;
+    std::string transcript_type;
+    std::vector<Region> exons;
+    std::vector<Region> cds;
+    // CDS range, including the start and stop codons
+    int cds_min = INT_MAX;
+    int cds_max = 0;
+    int is_canonical = 0;
+    std::string symbol;
+    std::vector<std::string> alt_ids;
+    std::map<std::string, std::string> attributes;
+};
+
+// find the index of the exon containing a given chromosome position
+static size_t get_exon_num(const std::vector<Region> & exons, int pos) {
+    for (size_t i = 0; i < exons.size(); i++) {
+        if ((pos >= exons[i].start) && (pos <= exons[i].end)) {
+            return i;
+        }
+    }
+    throw std::invalid_argument("can't find exon for an end codon");
+}
+
+// adjust CDS coords for any end codon positions
+// 
+// the CDS might exclude the start codon and end codon from the CDS range
+// we have collected the start and end codon ends in cds_min and cds_max. We
+// can't just set the first CDS coord and last CDS coord to their values though,
+// as at least one stop codon spans an intron boundary, which messes up the
+// CDS if included as is.
+static void include_end_codons(TxInfo & info) {
+    if (info.cds.empty()) {
+        return;
+    }
+    auto by_start = [](const Region & a, const Region & b) { return a.start < b.start; };
+    std::sort(info.cds.begin(), info.cds.end(), by_start);
+    std::sort(info.exons.begin(), info.exons.end(), by_start);
+
+    // handle left (5') boundary
+    size_t first_idx = get_exon_num(info.exons, info.cds[0].start);
+    size_t min_idx = get_exon_num(info.exons, info.cds_min);
+    if (min_idx == first_idx) {
+        info.cds[0].start = info.cds_min;
+    } else {
+        info.cds[0].start = info.exons[first_idx].start;  // extend existing CDS
+        info.cds.insert(info.cds.begin(), Region {info.cds_min, info.exons[min_idx].end});
+    }
+
+    // handle right (3') boundary
+    size_t last_idx = get_exon_num(info.exons, info.cds.back().end);
+    size_t max_idx = get_exon_num(info.exons, info.cds_max);
+    if (max_idx == last_idx) {
+        info.cds.back().end = info.cds_max;
+    } else {
+        info.cds.back().end = info.exons[last_idx].end;  // extend existing CDS
+        info.cds.push_back(Region {info.exons[max_idx].start, info.cds_max});
+    }
+}
+
+// set the transcript span from its exons and CDS, for GTFs without transcript lines
+static void set_span(TxInfo & info) {
+    if (info.start != 0 || info.end != 0) {
+        return;
+    }
+    bool first = true;
+    for (auto regions : {&info.exons, &info.cds}) {
+        for (auto & x : *regions) {
+            info.start = first ? x.start : std::min(info.start, x.start);
+            info.end = first ? x.end : std::max(info.end, x.end);
+            first = false;
+        }
+    }
+}
+
+// construct a Tx from the features collected for a transcript
+//
+// Transcripts with inconsistent coordinates (e.g. a stop codon outside the
+// exons) are skipped with a warning, so one malformed transcript doesn't stop
+// the rest of the GTF from loading.
+static void add_transcript(std::vector<NamedTx> & transcripts, TxInfo & info) {
+    try {
+        if (info.exons.empty()) {
+            throw std::invalid_argument("no exons");
+        }
+        include_end_codons(info);
+        set_span(info);
+        Tx tx(info.name, info.chrom, info.start, info.end, info.strand,
+            info.transcript_type, std::move(info.attributes));
+        tx.set_exons(std::move(info.exons));
+        tx.set_cds(std::move(info.cds));
+        transcripts.push_back({std::move(info.symbol), std::move(info.alt_ids),
+            std::move(tx), info.is_canonical});
+    } catch (const std::invalid_argument & e) {
+        std::cerr << "skipping transcript " << info.name << ": " << e.what() << std::endl;
+    }
+}
+
+// build transcripts in the order they first appeared, freeing each entry once
+// its transcript is built
+//
+// @param pos start of the current GTF line. Transcripts are only built once this
+//     passes their end, as no further lines for them can follow in a
+//     position-sorted GTF. Use -1 to build all transcripts.
+static void build_transcripts(std::vector<NamedTx> & transcripts,
+        std::deque<TxInfo> & entries, std::unordered_map<std::string, TxInfo *> & index,
+        int pos=-1) {
+    while (!entries.empty()) {
+        TxInfo & info = entries.front();
+        if (pos != -1 && (info.end == 0 || pos <= info.end)) {
+            break;
+        }
+        index.erase(info.name);
+        add_transcript(transcripts, info);
+        entries.pop_front();
+    }
+}
+
+// find the entry for a GTF line's transcript, or start a new one from the line
+static TxInfo * get_entry(std::deque<TxInfo> & entries,
+        std::unordered_map<std::string, TxInfo *> & index, GTFLine & gtf) {
+    auto it = index.find(gtf.tx_id);
+    if (it != index.end()) {
+        return it->second;
+    }
+    entries.emplace_back();
+    TxInfo * info = &entries.back();
+    index[gtf.tx_id] = info;
+
+    info->name = gtf.tx_id;
+    info->chrom = gtf.chrom;
+    info->strand = gtf.strand[0];
+    info->is_canonical = gtf.is_canonical;
+    info->transcript_type = gtf.transcript_type;
+    info->symbol = gtf.symbol;
+    info->alt_ids = gtf.alternate_ids;
+    if (gtf.feature != "transcript") {
+        // without a transcript line, use the first line's attributes, minus the
+        // fields specific to that feature
+        info->attributes = std::move(gtf.attributes);
+        for (auto field : {"exon_number", "exon_id", "exon_version"}) {
+            info->attributes.erase(field);
+        }
+    }
+    return info;
+}
+
+enum class Feature { other, transcript, exon, cds, codon, utr };
+
+static Feature get_feature(const std::string & feature) {
+    if (feature == "exon") { return Feature::exon; }
+    if (feature == "CDS") { return Feature::cds; }
+    if (feature == "UTR") { return Feature::utr; }
+    if (feature == "transcript") { return Feature::transcript; }
+    if (feature == "start_codon" || feature == "stop_codon") { return Feature::codon; }
+    return Feature::other;
+}
+
+// collect all features for a transcript into a single object
+//
+// When we load lines from gencode GTF files, each line represents a single exon
+// or CDS, and we need to combine these based on transcript ID. Lines for a
+// transcript are usually contiguous, but position-sorted GTFs interleave
+// transcripts, so features are collected by transcript ID until the chromosome
+// changes (GTFs are grouped by chromosome), or the GTF moves past the transcript.
+static void load_transcripts(std::vector<NamedTx> & transcripts, GTF & gtf_file, bool coding) {
+    std::deque<TxInfo> entries;
+    std::unordered_map<std::string, TxInfo *> index;
+    TxInfo * info = nullptr;
+    GTFLine gtf;
+
+    while (gtf_file.next(gtf)) {
+        Feature feature = get_feature(gtf.feature);
+        if (feature == Feature::other || (coding && gtf.transcript_type != "protein_coding")) {
+            continue;
+        }
+
+        // only look up the transcript when it differs from the previous line's
+        if (info == nullptr || gtf.tx_id != info->name || gtf.chrom != info->chrom) {
+            bool new_chrom = info != nullptr && gtf.chrom != info->chrom;
+            build_transcripts(transcripts, entries, index, new_chrom ? -1 : gtf.start);
+            info = get_entry(entries, index, gtf);
+        }
+
+        if (feature == Feature::transcript) {
+            info->start = gtf.start;
+            info->end = gtf.end;
+            info->attributes = std::move(gtf.attributes);
+        } else if (feature == Feature::exon) {
+            info->exons.push_back(Region {gtf.start, gtf.end});
+        } else if (feature == Feature::cds) {
+            info->cds.push_back(Region {gtf.start, gtf.end});
+        }
+        if (feature == Feature::cds || feature == Feature::codon) {
+            info->cds_min = std::min({info->cds_min, gtf.start, gtf.end});
+            info->cds_max = std::max({info->cds_max, gtf.start, gtf.end});
+        }
+    }
+
+    build_transcripts(transcripts, entries, index);
+}
+
+std::vector<NamedTx> open_gencode(std::string path, bool coding) {
+    GTF gtf_file(path);
+    std::vector<NamedTx> transcripts;
+    transcripts.reserve(80000);
+    load_transcripts(transcripts, gtf_file, coding);
+    return transcripts;
+}
+
+bool CompFunc(const GenePoint &l, const GenePoint &r) {
+    return l.pos < r.pos;
+}
+
+// find genes overlapping a region
+//
+// @param starts gene start positions per chromosome, sorted by position
+// @param ends gene end positions per chromosome, sorted by position
+// @param max_window maximum gene length, which limits how far beyond the region
+//     we search for genes that span the whole region
+// @returns keys for the genes overlapping the region
+std::vector<std::string> _in_region(std::string chrom, int start, int end, 
+        std::map<std::string, std::vector<GenePoint>> & starts, 
+        std::map<std::string, std::vector<GenePoint>> & ends,
+        int max_window) {
+    if (start > end) {
+        throw std::invalid_argument("region start (" + std::to_string(start)
+            + ") is after its end (" + std::to_string(end) + ")");
+    }
+    auto starts_it = starts.find(chrom);
+    if (starts_it == starts.end()) {
+        throw std::invalid_argument("unknown_chrom: " + chrom);
+    }
+    const std::vector<GenePoint> & chrom_starts = starts_it->second;
+    const std::vector<GenePoint> & chrom_ends = ends.at(chrom);
+    const int n_starts = (int) chrom_starts.size();
+    const int n_ends = (int) chrom_ends.size();
+    std::vector<std::string> symbols;
+
+    // find genes with a start inside the region
+    std::unordered_set<std::string> inside;
+    int first_start = std::lower_bound(chrom_starts.begin(), chrom_starts.end(),
+        GenePoint {start, ""}, CompFunc) - chrom_starts.begin();
+    for (int i = first_start; i < n_starts && chrom_starts[i].pos <= end; i++) {
+        inside.insert(chrom_starts[i].symbol);
+        symbols.push_back(chrom_starts[i].symbol);
+    }
+
+    // find genes with an end inside the region (that don't also start inside it)
+    int after_end = std::upper_bound(chrom_ends.begin(), chrom_ends.end(),
+        GenePoint {end, ""}, CompFunc) - chrom_ends.begin();
+    for (int i = after_end - 1; i >= 0 && chrom_ends[i].pos >= start; i--) {
+        if (inside.count(chrom_ends[i].symbol) == 0) {
+            symbols.push_back(chrom_ends[i].symbol);
+        }
+    }
+
+    if (std::abs(end - start) > max_window) {
+        // if the window is too wide to permit a gene to span it, just return
+        return symbols;
+    }
+
+    // find genes that span the region, i.e. start upstream and end downstream
+    std::unordered_set<std::string> starts_before;
+    for (int i = first_start - 1; i >= 0 && std::abs(chrom_starts[i].pos - end) <= max_window; i--) {
+        starts_before.insert(chrom_starts[i].symbol);
+    }
+    for (int i = after_end; i < n_ends && std::abs(chrom_ends[i].pos - start) <= max_window; i++) {
+        if (starts_before.count(chrom_ends[i].symbol) != 0) {
+            symbols.push_back(chrom_ends[i].symbol);
+        }
+    }
+
+    return symbols;
+}
+
+} // namespace

{gencodegenes-1.2.0 → gencodegenes-1.2.2}/src/gencode.h

@@ -1,33 +1,14 @@
 #ifndef GENCODEGENES_GENCODE_H_
 #define GENCODEGENES_GENCODE_H_
 
-#include <cstdint>
-#include <fstream>
 #include <string>
 #include <map>
 #include <vector>
-#include <set>
 
-#include "gtf.h"
 #include "tx.h"
 
 namespace gencode {
 
-// collects info for a transcript, so we can later construct a Tx object
-struct TxInfo {
-    std::string name = "";
-    std::string chrom;
-    int start = 0;
-    int end = 0;
-    std::string strand;
-    std::string transcript_type;
-    std::vector<std::vector<int> > exons;
-    std::vector<std::vector<int> > cds;
-    int offset = 0;
-    int is_canonical = 0;
-    std::map<std::string, std::string> attributes;
-};
-
 // stores HGNC symbol with the transcript, so we can collect transcripts by gene
 struct NamedTx {
     std::string symbol;
@@ -53,4 +34,3 @@ std::vector<std::string> _in_region(std::string chrom, int start, int end,
 } // namespace
 
 #endif // GENCODEGENES_GENCODE_H_
-