gtfparse 2.1.0__py3-none-any.whl

gtfparse/__init__.py

@@ -0,0 +1,37 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .attribute_parsing import expand_attribute_strings
+from .create_missing_features import create_missing_features
+from .parsing_error import ParsingError
+from .read_gtf import (
+    read_gtf, 
+    parse_gtf,
+    parse_gtf_pandas, 
+    parse_gtf_and_expand_attributes, 
+    REQUIRED_COLUMNS,
+)
+
+__version__ = "2.1.0"
+
+__all__ = [
+    "__version__",
+    "expand_attribute_strings",
+    "create_missing_features",
+
+    "parse_gtf_and_expand_attributes",
+    "REQUIRED_COLUMNS",
+    "ParsingError",
+    "read_gtf",
+    "parse_gtf",
+    "parse_gtf_pandas",
+]

gtfparse/attribute_parsing.py

@@ -0,0 +1,116 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+from collections import OrderedDict
+from sys import intern
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+
+def expand_attribute_strings(
+        attribute_strings,
+        quote_char="'",
+        missing_value="",
+        usecols=None):
+    """
+    The last column of GTF has a variable number of key value pairs
+    of the format: "key1 value1; key2 value2;"
+    Parse these into a dictionary mapping each key onto a list of values,
+    where the value is None for any row where the key was missing.
+
+    Parameters
+    ----------
+    attribute_strings : list of str
+
+    quote_char : str
+        Quote character to remove from values
+
+    missing_value : any
+        If an attribute is missing from a row, give it this value.
+
+    usecols : list of str or None
+        If not None, then only expand columns included in this set,
+        otherwise use all columns.
+
+    Returns OrderedDict of column->value list mappings, in the order they
+    appeared in the attribute strings.
+    """
+    n = len(attribute_strings)
+
+    extra_columns = {}
+    column_order = []
+
+    #
+    # SOME NOTES ABOUT THE BIZARRE STRING INTERNING GOING ON BELOW
+    #
+    # While parsing millions of repeated strings (e.g. "gene_id" and "TP53"),
+    # we can save a lot of memory by making sure there's only one string
+    # object per unique string. The canonical way to do this is using
+    # the 'intern' function. One problem is that Py2 won't let you intern
+    # unicode objects, so to get around this we call intern(str(...)).
+    #
+    # It also turns out to be faster to check interned strings ourselves
+    # using a local dictionary, hence the two dictionaries below
+    # and pair of try/except blocks in the loop.
+    column_interned_strings = {}
+
+    for (i, kv_strings) in enumerate(attribute_strings):
+        if type(kv_strings) is str:
+            kv_strings = kv_strings.split(";")
+        for kv in kv_strings:
+            # We're slicing the first two elements out of split() because
+            # Ensembl release 79 added values like:
+            #   transcript_support_level "1 (assigned to previous version 5)";
+            # ...which gets mangled by splitting on spaces.
+            parts = kv.strip().split(" ", 2)[:2]
+
+            if len(parts) != 2:
+                continue
+
+            column_name, value = parts
+
+            try:
+                column_name = column_interned_strings[column_name]
+            except KeyError:
+                column_name = intern(str(column_name))
+                column_interned_strings[column_name] = column_name
+
+            if usecols is not None and column_name not in usecols:
+                continue
+
+            if value[0] == quote_char:
+                value = value.replace(quote_char, "")
+                
+            try:
+                column = extra_columns[column_name]
+                # if an attribute is used repeatedly then
+                # keep track of all its values in a list
+                old_value = column[i]
+                if old_value is missing_value:
+                    column[i] = value
+                else:
+                    column[i] = "%s,%s" % (old_value, value)
+            except KeyError:
+                column = [missing_value] * n
+                column[i] = value
+                extra_columns[column_name] = column
+                column_order.append(column_name)
+
+
+
+    logging.info("Extracted GTF attributes: %s" % column_order)
+    return OrderedDict(
+        (column_name, extra_columns[column_name])
+        for column_name in column_order)

gtfparse/create_missing_features.py

@@ -0,0 +1,118 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+from collections import OrderedDict
+
+import pandas as pd
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def create_missing_features(
+        dataframe,
+        unique_keys={},
+        extra_columns={},
+        missing_value=None):
+    """
+    Helper function used to construct a missing feature such as 'transcript'
+    or 'gene'. Some GTF files only have 'exon' and 'CDS' entries, but have
+    transcript_id and gene_id annotations which allow us to construct those
+    missing features.
+
+    Parameters
+    ----------
+    dataframe : pandas.DataFrame
+        Should contain at least the core GTF columns, such as "seqname",
+        "start", and "end"
+
+    unique_keys : dict
+        Mapping from feature names to the name of the column which should
+        act as a unique key for that feature. Example: {"gene": "gene_id"}
+
+    extra_columns : dict
+        By default the constructed feature row will include only the 8
+        core columns and its unique key. Any other columns that should
+        be included should be associated with the feature name in this
+        dict.
+
+    missing_value : any
+        Which value to fill in for columns that we don't infer values for.
+
+    Returns original dataframe along with all extra rows created for missing
+    features.
+    """
+    extra_dataframes = []
+
+    existing_features = set(dataframe["feature"])
+    existing_columns = set(dataframe.columns)
+
+    for (feature_name, groupby_key) in unique_keys.items():
+        if feature_name in existing_features:
+            logging.info(
+                "Feature '%s' already exists in GTF data" % feature_name)
+            continue
+        logging.info("Creating rows for missing feature '%s'" % feature_name)
+
+        # don't include rows where the groupby key was missing
+        empty_key_values = dataframe[groupby_key].map(
+            lambda x: x == "" or x is None)
+        row_groups = dataframe[~empty_key_values].groupby(groupby_key)
+
+        # Each group corresponds to a unique feature entry for which the
+        # other columns may or may not be uniquely defined. Start off by
+        # assuming the values for every column are missing and fill them in
+        # where possible.
+        feature_values = OrderedDict([
+            (column_name, [missing_value] * row_groups.ngroups)
+            for column_name in dataframe.keys()
+        ])
+
+        # User specifies which non-required columns should we try to infer
+        # values for
+        feature_columns = list(extra_columns.get(feature_name, []))
+
+        for i, (feature_id, group) in enumerate(row_groups):
+            # fill in the required columns by assuming that this feature
+            # is the union of all intervals of other features that were
+            # tagged with its unique ID (e.g. union of exons which had a
+            # particular gene_id).
+            feature_values["feature"][i] = feature_name
+            feature_values[groupby_key][i] = feature_id
+            # set the source to 'gtfparse' to indicate that we made this
+            # entry up from other data
+            feature_values["source"][i] = "gtfparse"
+            feature_values["start"][i] = group["start"].min()
+            feature_values["end"][i] = group["end"].max()
+
+            # assume that seqname and strand are the same for all other
+            # entries in the GTF which shared this unique ID
+            feature_values["seqname"][i] = group["seqname"].iat[0]
+            feature_values["strand"][i] = group["strand"].iat[0]
+
+            # there's probably no rigorous way to set the values of
+            # 'score' or 'frame' columns so leave them empty
+            for column_name in feature_columns:
+                if column_name not in existing_columns:
+                    raise ValueError(
+                        "Column '%s' does not exist in GTF, columns = %s" % (
+                            column_name, existing_columns))
+
+                # expect that all entries related to a reconstructed feature
+                # are related and are thus within the same interval of
+                # positions on the same chromosome
+                unique_values = group[column_name].dropna().unique()
+                if len(unique_values) == 1:
+                    feature_values[column_name][i] = unique_values[0]
+        extra_dataframes.append(pd.DataFrame(feature_values))
+    return pd.concat([dataframe] + extra_dataframes, ignore_index=True)

gtfparse/parsing_error.py

@@ -0,0 +1,14 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class ParsingError(Exception):
+    pass

gtfparse/read_gtf.py

@@ -0,0 +1,297 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+from os.path import exists
+from io import StringIO
+import gzip 
+
+import polars 
+
+from .attribute_parsing import expand_attribute_strings
+from .parsing_error import ParsingError
+
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+"""
+Columns of a GTF file:
+
+    seqname   - name of the chromosome or scaffold; chromosome names
+                without a 'chr' in Ensembl (but sometimes with a 'chr'
+                elsewhere)
+    source    - name of the program that generated this feature, or
+                the data source (database or project name)
+    feature   - feature type name.
+                Features currently in Ensembl GTFs:
+                    gene
+                    transcript
+                    exon
+                    CDS
+                    Selenocysteine
+                    start_codon
+                    stop_codon
+                    UTR
+                Older Ensembl releases may be missing some of these features.
+    start     - start position of the feature, with sequence numbering
+                starting at 1.
+    end       - end position of the feature, with sequence numbering
+                starting at 1.
+    score     - a floating point value indiciating the score of a feature
+    strand    - defined as + (forward) or - (reverse).
+    frame     - one of '0', '1' or '2'. Frame indicates the number of base pairs
+                before you encounter a full codon. '0' indicates the feature
+                begins with a whole codon. '1' indicates there is an extra
+                base (the 3rd base of the prior codon) at the start of this feature.
+                '2' indicates there are two extra bases (2nd and 3rd base of the
+                prior exon) before the first codon. All values are given with
+                relation to the 5' end.
+    attribute - a semicolon-separated list of tag-value pairs (separated by a space),
+                providing additional information about each feature. A key can be
+                repeated multiple times.
+
+(from ftp://ftp.ensembl.org/pub/release-75/gtf/homo_sapiens/README)
+"""
+
+REQUIRED_COLUMNS = [
+    "seqname",
+    "source",
+    "feature",
+    "start",
+    "end",
+    "score",
+    "strand",
+    "frame",
+    "attribute",
+]
+
+
+def parse_with_polars_lazy(
+        filepath_or_buffer,
+        split_attributes=True,
+        features=None,
+        fix_quotes_columns=["attribute"]):
+    # use a global string cache so that all strings get intern'd into
+    # a single numbering system
+    polars.enable_string_cache()
+    kwargs = dict(
+        has_header=False,
+        separator="\t",
+        comment_prefix="#",
+        null_values=".",
+        dtypes={
+            "seqname": polars.Categorical, 
+            "source": polars.Categorical, 
+            
+            "start": polars.Int64,
+            "end": polars.Int64,
+            "score": polars.Float32,
+
+            "feature": polars.Categorical, 
+            "strand": polars.Categorical, 
+            "frame": polars.UInt32,
+        })
+    try:
+        if type(filepath_or_buffer) is StringIO:
+            df = polars.read_csv(
+                filepath_or_buffer,
+                new_columns=REQUIRED_COLUMNS,
+                **kwargs).lazy()
+        elif filepath_or_buffer.endswith(".gz") or filepath_or_buffer.endswith(".gzip"):
+            with gzip.open(filepath_or_buffer) as f:
+                df = polars.read_csv(
+                    f,
+                    new_columns=REQUIRED_COLUMNS,
+                    **kwargs).lazy()
+        else:
+            df = polars.scan_csv(
+                filepath_or_buffer, 
+                with_column_names=lambda cols: REQUIRED_COLUMNS,
+                **kwargs).lazy()
+    except polars.ShapeError:
+        raise ParsingError("Wrong number of columns")
+
+    df = df.with_columns([
+        polars.col("frame").fill_null(0),
+        polars.col("attribute").str.replace_all('"', "'")
+    ])
+    
+    for fix_quotes_column in fix_quotes_columns:
+        # Catch mistaken semicolons by replacing "xyz;" with "xyz"
+        # Required to do this since the Ensembl GTF for Ensembl
+        # release 78 has mistakes such as:
+        #   gene_name = "PRAMEF6;" transcript_name = "PRAMEF6;-201"
+        df = df.with_columns([
+            polars.col(fix_quotes_column).str.replace(';\"', '\"').str.replace(";-", "-")
+        ])
+
+    if features is not None:
+        features = sorted(set(features))
+        df = df.filter(polars.col("feature").is_in(features))
+
+
+    if split_attributes:
+        df = df.with_columns([
+            polars.col("attribute").str.split(";").alias("attribute_split")
+        ])
+    return df
+
+def parse_gtf(
+        filepath_or_buffer, 
+        split_attributes=True, 
+        features=None,
+        fix_quotes_columns=["attribute"]):
+    df_lazy = parse_with_polars_lazy(
+        filepath_or_buffer=filepath_or_buffer,
+        split_attributes=split_attributes,
+        features=features,
+        fix_quotes_columns=fix_quotes_columns)
+    return df_lazy.collect()
+
+def parse_gtf_pandas(*args, **kwargs):
+    return parse_gtf(*args, **kwargs).to_pandas()
+
+    
+def parse_gtf_and_expand_attributes(
+        filepath_or_buffer,
+        restrict_attribute_columns=None,
+        features=None):
+    """
+    Parse lines into column->values dictionary and then expand
+    the 'attribute' column into multiple columns. This expansion happens
+    by replacing strings of semi-colon separated key-value values in the
+    'attribute' column with one column per distinct key, with a list of
+    values for each row (using None for rows where key didn't occur).
+
+    Parameters
+    ----------
+    filepath_or_buffer : str or buffer object
+
+    chunksize : int
+
+    restrict_attribute_columns : list/set of str or None
+        If given, then only use these attribute columns.
+
+    features : set or None
+        Ignore entries which don't correspond to one of the supplied features
+    """
+    df = parse_gtf(
+        filepath_or_buffer=filepath_or_buffer, 
+        features=features,
+        split_attributes=True)
+    if type(restrict_attribute_columns) is str:
+        restrict_attribute_columns = {restrict_attribute_columns}
+    elif restrict_attribute_columns:
+        restrict_attribute_columns = set(restrict_attribute_columns)
+    df.drop_in_place("attribute")
+    attribute_pairs = df.drop_in_place("attribute_split")
+    return df.with_columns([
+        polars.Series(k, vs)
+        for (k, vs) in 
+        expand_attribute_strings(attribute_pairs).items()
+        if restrict_attribute_columns is None or k in restrict_attribute_columns
+    ])
+    
+
+def read_gtf(
+        filepath_or_buffer,
+        expand_attribute_column=True,
+        infer_biotype_column=False,
+        column_converters={},
+        usecols=None,
+        features=None,
+        result_type='polars'):
+    """
+    Parse a GTF into a dictionary mapping column names to sequences of values.
+
+    Parameters
+    ----------
+    filepath_or_buffer : str or buffer object
+        Path to GTF file (may be gzip compressed) or buffer object
+        such as StringIO
+
+    expand_attribute_column : bool
+        Replace strings of semi-colon separated key-value values in the
+        'attribute' column with one column per distinct key, with a list of
+        values for each row (using None for rows where key didn't occur).
+
+    infer_biotype_column : bool
+        Due to the annoying ambiguity of the second GTF column across multiple
+        Ensembl releases, figure out if an older GTF's source column is actually
+        the gene_biotype or transcript_biotype.
+
+    column_converters : dict, optional
+        Dictionary mapping column names to conversion functions. Will replace
+        empty strings with None and otherwise passes them to given conversion
+        function.
+
+    usecols : list of str or None
+        Restrict which columns are loaded to the give set. If None, then
+        load all columns.
+
+    features : set of str or None
+        Drop rows which aren't one of the features in the supplied set
+
+    result_type : One of 'polars', 'pandas', or 'dict'
+        Default behavior is to return a Polars DataFrame, but will convert to 
+        Pandas DataFrame or dictionary if specified.
+    """
+    if type(filepath_or_buffer) is str and not exists(filepath_or_buffer):
+        raise ValueError("GTF file does not exist: %s" % filepath_or_buffer)
+
+    if expand_attribute_column:
+        result_df = parse_gtf_and_expand_attributes(
+            filepath_or_buffer,
+            restrict_attribute_columns=usecols,
+            features=features)
+    else:
+        result_df = parse_gtf(result_df, features=features)
+
+    result_df = result_df.with_columns(
+        [
+            polars.col(column_name).map_elements(lambda x: column_type(x) if len(x) > 0 else None)
+            for column_name, column_type in column_converters.items()
+        ]
+    )
+
+    # Hackishly infer whether the values in the 'source' column of this GTF
+    # are actually representing a biotype by checking for the most common
+    # gene_biotype and transcript_biotype value 'protein_coding'
+    if infer_biotype_column:
+        unique_source_values = set(result_df["source"])
+        if "protein_coding" in unique_source_values:
+            column_names = set(result_df.columns)
+            # Disambiguate between the two biotypes by checking if
+            # gene_biotype is already present in another column. If it is,
+            # the 2nd column is the transcript_biotype (otherwise, it's the
+            # gene_biotype)
+            if "gene_biotype" not in column_names:
+                logging.info("Using column 'source' to replace missing 'gene_biotype'")
+                result_df = result_df.with_column(polars.col("source").alias("gene_biotype"))
+            if "transcript_biotype" not in column_names:
+                logging.info("Using column 'source' to replace missing 'transcript_biotype'")
+                result_df = result_df.with_column(polars.col("source").alias("transcript_biotype"))
+
+    if usecols is not None:
+        column_names = set(result_df.columns)
+        valid_columns = [c for c in usecols if c in column_names]
+        result_df = result_df.select(valid_columns)
+
+    if result_type == "pandas":
+        result = result_df.to_pandas()
+    elif result_type == "polars":
+        result = result_df
+    elif result_type == "dict":
+        result = result_df.to_dict()
+    return result

gtfparse-2.1.0.dist-info/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

gtfparse-2.1.0.dist-info/METADATA

@@ -0,0 +1,64 @@
+Metadata-Version: 2.1
+Name: gtfparse
+Version: 2.1.0
+Summary: Parsing library for extracting data frames of genomic features from GTF files
+Author-email: Alex Rubinsteyn <alex.rubinsteyn@unc.edu>
+Project-URL: Homepage, https://github.com/openvax/gtfparse
+Project-URL: Bug Tracker, https://github.com/openvax/gtfparse
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: polars <0.21.0,>=0.20.2
+Requires-Dist: pyarrow <14.1.0,>=14.0.2
+
+[![Build Status](https://travis-ci.org/openvax/gtfparse.svg?branch=master)](https://travis-ci.org/openvax/gtfparse) [![Coverage Status](https://coveralls.io/repos/openvax/gtfparse/badge.svg?branch=master&service=github)](https://coveralls.io/github/openvax/gtfparse?branch=master)
+<a href="https://pypi.python.org/pypi/gtfparse/">
+    <img src="https://img.shields.io/pypi/v/gtfparse.svg?maxAge=1000" alt="PyPI" />
+</a>
+
+gtfparse
+========
+Parsing tools for GTF (gene transfer format) files.
+
+# Example usage
+
+## Parsing all rows of a GTF file into a Pandas DataFrame
+
+```python
+from gtfparse import read_gtf
+
+# returns GTF with essential columns such as "feature", "seqname", "start", "end"
+# alongside the names of any optional keys which appeared in the attribute column
+df = read_gtf("gene_annotations.gtf")
+
+# filter DataFrame to gene entries on chrY
+df_genes = df[df["feature"] == "gene"]
+df_genes_chrY = df_genes[df_genes["seqname"] == "Y"]
+```
+
+
+## Getting gene FPKM values from a StringTie GTF file
+
+```python
+from gtfparse import read_gtf
+
+df = read_gtf(
+    "Transcripts.gtf",
+    column_converters={"FPKM": float})
+
+gene_fpkms = {
+    gene_name: fpkm
+    for (gene_name, fpkm, feature)
+    in zip(df["seqname"], df["FPKM"], df["feature"])
+    if feature == "gene"
+}
+```
+
+

gtfparse-2.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+requirements.txt,sha256=7ScTRNppQy5B2g6C7SL-AorMzyr5PC0KLt3tlRREfGg,47
+gtfparse/__init__.py,sha256=FUhwxf_r14CWWYOLSo-pVLEDCQjEofpVgEg7uqnbbPY,1102
+gtfparse/attribute_parsing.py,sha256=U579OuulIBhRdHsPmS33wePwiJ0qxsfNNY7y-1-KBuo,4134
+gtfparse/create_missing_features.py,sha256=CGwxlyS9trrse7u3KKg8mFmuGoli2wFEBJ-n4XEzlpw,5016
+gtfparse/parsing_error.py,sha256=dWjxGGIhpZDEnWjrRp0hxk3Ut7BaYujYT-8DhlCnBMI,585
+gtfparse/read_gtf.py,sha256=D7vCaKOBy8wqvmQEXcMcykh8_dFYFs6bd3sngsrnfng,10986
+gtfparse-2.1.0.dist-info/LICENSE,sha256=xllut76FgcGL5zbIRvuRc7aezPbvlMUTWJPsVr2Sugg,11358
+gtfparse-2.1.0.dist-info/METADATA,sha256=p5hbzxLHX9tIo4Ecr7rNpsA1EfKeBN_2ZZ06tbSJYQ4,2108
+gtfparse-2.1.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+gtfparse-2.1.0.dist-info/top_level.txt,sha256=7j2M9WSTNQye5-GDW_wLZfLoa10e4YfFKw-cAeVxFPM,9
+gtfparse-2.1.0.dist-info/RECORD,,

gtfparse-2.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gtfparse-2.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+gtfparse

requirements.txt

@@ -0,0 +1,2 @@
+polars>=0.20.2,<0.21.0
+pyarrow>=14.0.2,<14.1.0