gtfparse 2.6.2__tar.gz → 2.7.0__tar.gz

{gtfparse-2.6.2 → gtfparse-2.7.0}/PKG-INFO

@@ -1,23 +1,33 @@
 Metadata-Version: 2.4
 Name: gtfparse
-Version: 2.6.2
+Version: 2.7.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
+Project-URL: Bug Tracker, https://github.com/openvax/gtfparse/issues
 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: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: polars>=0.20.2
 Requires-Dist: pyarrow>=18.0.0
 Requires-Dist: pandas>=2.1.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: coveralls; extra == "dev"
 Dynamic: license-file
 
 [![Tests](https://github.com/openvax/gtfparse/actions/workflows/tests.yml/badge.svg)](https://github.com/openvax/gtfparse/actions/workflows/tests.yml)

{gtfparse-2.6.2 → gtfparse-2.7.0}/gtfparse/__init__.py

@@ -14,23 +14,27 @@ 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,
+    GENCODE_BIOTYPE_ALIASES,
+    INTEGER_VERSION_COLUMNS,
+    REQUIRED_COLUMNS,
     parse_gtf,
-    parse_gtf_pandas,
     parse_gtf_and_expand_attributes,
-    REQUIRED_COLUMNS,
+    parse_gtf_pandas,
+    read_gtf,
 )
 
-__version__ = "2.6.2"
+__version__ = "2.7.0"
 
 __all__ = [
-    "__version__",
-    "expand_attribute_strings",
-    "create_missing_features",
-    "parse_gtf_and_expand_attributes",
+    "GENCODE_BIOTYPE_ALIASES",
+    "INTEGER_VERSION_COLUMNS",
     "REQUIRED_COLUMNS",
     "ParsingError",
-    "read_gtf",
+    "__version__",
+    "create_missing_features",
+    "expand_attribute_strings",
     "parse_gtf",
+    "parse_gtf_and_expand_attributes",
     "parse_gtf_pandas",
+    "read_gtf",
 ]

{gtfparse-2.6.2 → gtfparse-2.7.0}/gtfparse/attribute_parsing.py

@@ -18,12 +18,7 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
-
-def expand_attribute_strings(
-        attribute_strings,
-        quote_char="'",
-        missing_value="",
-        usecols=None):
+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;"
@@ -66,7 +61,7 @@ def expand_attribute_strings(
     # and pair of try/except blocks in the loop.
     column_interned_strings = {}
 
-    for (i, kv_strings) in enumerate(attribute_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:
@@ -92,7 +87,7 @@ def expand_attribute_strings(
 
             if value[0] == quote_char:
                 value = value.replace(quote_char, "")
-                
+
             try:
                 column = extra_columns[column_name]
                 # if an attribute is used repeatedly then
@@ -108,9 +103,5 @@ def expand_attribute_strings(
                 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)
+    return OrderedDict((column_name, extra_columns[column_name]) for column_name in column_order)

{gtfparse-2.6.2 → gtfparse-2.7.0}/gtfparse/create_missing_features.py

@@ -19,11 +19,7 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
-def create_missing_features(
-        dataframe,
-        unique_keys={},
-        extra_columns={},
-        missing_value=None):
+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
@@ -49,29 +45,25 @@ def create_missing_features(
     missing_value : any
         Which value to fill in for columns that we don't infer values for.
 
-    Returns original dataframe (converted to Pandas if necessary) along with all 
+    Returns original dataframe (converted to Pandas if necessary) along with all
     extra rows created for missing features.
     """
     if hasattr(dataframe, "to_pandas"):
         dataframe = dataframe.to_pandas()
-  
+
     extra_dataframes = []
 
     existing_features = set(dataframe["feature"])
     existing_columns = set(dataframe.columns)
- 
-    for (feature_name, groupby_key) in unique_keys.items():
-        
+
+    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)
+            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
-        missing = pd.Series([
-            x is None or x == ""
-            for x in dataframe[groupby_key]])
+        missing = pd.Series([x is None or x == "" for x in dataframe[groupby_key]])
         not_missing = ~missing
         row_groups = dataframe[not_missing].groupby(groupby_key)
 
@@ -79,10 +71,9 @@ def create_missing_features(
         # 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()
-        ])
+        feature_values = OrderedDict(
+            [(column_name, [missing_value] * row_groups.ngroups) for column_name in dataframe]
+        )
 
         # User specifies which non-required columns should we try to infer
         # values for
@@ -111,8 +102,9 @@ def create_missing_features(
             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))
+                        "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
@@ -121,4 +113,4 @@ def create_missing_features(
                 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)
+    return pd.concat([dataframe, *extra_dataframes], ignore_index=True)

{gtfparse-2.6.2 → gtfparse-2.7.0}/gtfparse/parsing_error.py

@@ -10,5 +10,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+
 class ParsingError(Exception):
     pass

{gtfparse-2.6.2 → gtfparse-2.7.0}/gtfparse/read_gtf.py

@@ -13,16 +13,37 @@
 import logging
 from os.path import exists
 
-import polars 
+import pandas as pd
+import polars
 
 from .attribute_parsing import expand_attribute_strings
 from .parsing_error import ParsingError
 
-
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
+# GENCODE GTFs use *_type where Ensembl GTFs use *_biotype. Pass this
+# (or a superset) as `attribute_aliases` to read_gtf to normalize a
+# GENCODE-format GTF onto the Ensembl column names that downstream
+# tools like pyensembl expect.
+GENCODE_BIOTYPE_ALIASES = {
+    "gene_type": "gene_biotype",
+    "transcript_type": "transcript_biotype",
+}
+
+
+# Ensembl-style attribute columns that are always integer-valued when
+# present. read_gtf casts these from string to pandas nullable Int64 by
+# default; pass cast_version_columns=False to keep them as strings.
+INTEGER_VERSION_COLUMNS = (
+    "gene_version",
+    "transcript_version",
+    "protein_version",
+    "exon_version",
+)
+
+
 """
 Columns of a GTF file:
 
@@ -76,88 +97,79 @@ REQUIRED_COLUMNS = [
 
 
 DEFAULT_COLUMN_DTYPES = {
-    "seqname": polars.Categorical, 
-    "source": polars.Categorical, 
-    
+    "seqname": polars.Categorical,
+    "source": polars.Categorical,
     "start": polars.Int64,
     "end": polars.Int64,
     "score": polars.Float32,
-
-    "feature": polars.Categorical, 
-    "strand": polars.Categorical, 
+    "feature": polars.Categorical,
+    "strand": polars.Categorical,
     "frame": polars.UInt32,
 }
 
+
 def parse_with_polars_lazy(
-        filepath_or_buffer,
-        split_attributes=True,
-        features=None,
-        fix_quotes_columns=["attribute"]):
+    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=".",
-        schema_overrides=DEFAULT_COLUMN_DTYPES)
+    kwargs = {
+        "has_header": False,
+        "separator": "\t",
+        "comment_prefix": "#",
+        "null_values": ".",
+        "schema_overrides": DEFAULT_COLUMN_DTYPES,
+    }
     try:
-        df = polars.read_csv(
-                filepath_or_buffer,
-                new_columns=REQUIRED_COLUMNS,
-                **kwargs).lazy()
-    except polars.exceptions.ShapeError:
-        raise ParsingError("Wrong number of columns")
+        df = polars.read_csv(filepath_or_buffer, new_columns=REQUIRED_COLUMNS, **kwargs).lazy()
+    except polars.exceptions.ShapeError as err:
+        raise ParsingError("Wrong number of columns") from err
 
     # Drop empty lines that may appear as all-null rows
     df = df.filter(polars.col("seqname").is_not_null())
 
-    df = df.with_columns([
-        polars.col("frame").fill_null(0),
-        polars.col("attribute").str.replace_all('"', "'")
-    ])
-    
+    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(";-", "-")
-        ])
+        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")
-        ])
+        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"]):
+    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)
+        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):
+    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
@@ -177,33 +189,93 @@ def parse_gtf_and_expand_attributes(
     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)
+    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
-    ])
-    
+    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 _apply_attribute_aliases(result_df, attribute_aliases):
+    """
+    Rename alias attribute columns onto canonical names in-place.
+
+    For each (alias -> canonical) pair, in iteration order:
+      * if only the alias is present, rename it to the canonical name.
+      * if both are present, drop the alias and warn (canonical wins).
+      * if neither is present, do nothing.
+
+    When two aliases target the same canonical (e.g. both ``gene_type``
+    and a hypothetical ``gene_kind`` map to ``gene_biotype``), the first
+    rename in iteration order wins; subsequent aliases targeting an
+    already-renamed canonical are treated as collisions, dropped, and
+    warned about.
+    """
+    if not attribute_aliases:
+        return result_df
+    columns_present = set(result_df.columns)
+    rename_map = {}
+    drop_aliases = []
+    for alias, canonical in attribute_aliases.items():
+        if alias not in columns_present:
+            continue
+        if canonical in columns_present:
+            logger.warning(
+                "Both alias column '%s' and canonical column '%s' are present; "
+                "dropping alias and keeping canonical values.",
+                alias,
+                canonical,
+            )
+            drop_aliases.append(alias)
+        else:
+            rename_map[alias] = canonical
+            # Reflect the rename in the running column set so a later
+            # alias mapping to the same canonical sees the collision
+            # instead of silently producing a duplicate-named column.
+            columns_present.discard(alias)
+            columns_present.add(canonical)
+    if drop_aliases:
+        result_df = result_df.drop(columns=drop_aliases)
+    if rename_map:
+        result_df = result_df.rename(columns=rename_map)
+    return result_df
+
+
+def _cast_version_columns(result_df, version_columns=INTEGER_VERSION_COLUMNS):
+    """
+    Cast known Ensembl *_version attribute columns from strings to
+    pandas nullable Int64 in-place. Missing/empty values become pd.NA.
+    """
+    for column_name in version_columns:
+        if column_name not in result_df.columns:
+            continue
+        result_df[column_name] = pd.to_numeric(
+            result_df[column_name].replace("", None), errors="coerce"
+        ).astype("Int64")
+    return result_df
+
 
 def read_gtf(
-        filepath_or_buffer,
-        expand_attribute_column=True,
-        infer_biotype_column=False,
-        column_converters={},
-        column_cast_types={},
-        usecols=None,
-        features=None,
-        result_type='polars'):
+    filepath_or_buffer,
+    expand_attribute_column=True,
+    infer_biotype_column=False,
+    column_converters={},
+    column_cast_types={},
+    usecols=None,
+    features=None,
+    result_type="polars",
+    attribute_aliases=None,
+    cast_version_columns=True,
+):
     """
     Parse a GTF into a dictionary mapping column names to sequences of values.
 
@@ -231,7 +303,7 @@ def read_gtf(
     column_cast_types : dict, optional
         Dictionary mapping column names to dtypes. Will cast columns to given
         Polars types.
-    
+
     usecols : list of str or None
         Restrict which columns are loaded to the give set. If None, then
         load all columns.
@@ -240,17 +312,47 @@ def read_gtf(
         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 
+        Default behavior is to return a Polars DataFrame, but will convert to
         Pandas DataFrame or dictionary if specified.
+
+    attribute_aliases : dict of str -> str, optional
+        Maps alias attribute names onto canonical ones. After attributes
+        are expanded into columns, each alias column is renamed to its
+        canonical name when the canonical column is absent. If both are
+        present the alias is dropped and a warning is logged. Pass
+        `GENCODE_BIOTYPE_ALIASES` to normalize a GENCODE GTF's
+        `gene_type`/`transcript_type` onto Ensembl's
+        `gene_biotype`/`transcript_biotype`.
+
+    cast_version_columns : bool
+        When True (default), cast the well-known integer version
+        attribute columns (`gene_version`, `transcript_version`,
+        `protein_version`, `exon_version`) from strings to pandas
+        nullable Int64 when present. Set to False to keep them as
+        strings.
     """
     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 usecols asks for a canonical column that's only present in the
+    # GTF under an alias name, expand the parse-time column filter to
+    # also pull the alias through — otherwise it gets dropped at parse
+    # time before _apply_attribute_aliases can see it. The end-of-function
+    # usecols filter still narrows the result down to the canonical name.
+    parse_usecols = usecols
+    if usecols is not None and attribute_aliases:
+        usecols_set = set(usecols)
+        parse_usecols = set(usecols_set)
+        for alias, canonical in attribute_aliases.items():
+            if canonical in usecols_set:
+                parse_usecols.add(alias)
+
     if expand_attribute_column:
         result_df = parse_gtf_and_expand_attributes(
             filepath_or_buffer,
-            restrict_attribute_columns=usecols,
-            features=features)
+            restrict_attribute_columns=parse_usecols,
+            features=features,
+        )
     else:
         result_df = parse_gtf(result_df, features=features)
 
@@ -259,26 +361,36 @@ def read_gtf(
     # and are generally insane to chase down
     result_df = result_df.to_pandas()
     if column_converters or column_cast_types:
+
         def wrap_to_always_accept_none(f):
             def wrapped_fn(x):
                 if x is None or x == "":
                     return None
                 else:
                     return f(x)
+
             return wrapped_fn
-        
+
         column_names = set(column_converters.keys()).union(column_cast_types.keys())
         for column_name in column_names:
-     
             if column_name in column_converters:
-                column_fn = wrap_to_always_accept_none(
-                    column_converters[column_name])
+                column_fn = wrap_to_always_accept_none(column_converters[column_name])
                 result_df[column_name] = result_df[column_name].apply(column_fn)
 
             if column_name in column_cast_types:
                 column_type = column_cast_types[column_name]
                 result_df[column_name] = result_df[column_name].astype(column_type)
-            
+
+    # Rename alias attribute columns onto their canonical names. Done before
+    # infer_biotype_column so an aliased gene_biotype/transcript_biotype is
+    # visible to the inference logic.
+    result_df = _apply_attribute_aliases(result_df, attribute_aliases)
+
+    # Cast Ensembl *_version columns from strings to nullable integers so
+    # downstream consumers (e.g. pyensembl) don't have to int(...) themselves.
+    if cast_version_columns:
+        result_df = _cast_version_columns(result_df)
+
     # 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'
@@ -292,11 +404,11 @@ def read_gtf(
             # gene_biotype)
             if "gene_biotype" not in column_names:
                 logging.info("Using column 'source' to replace missing 'gene_biotype'")
-                result_df['gene_biotype'] = result_df['source']
+                result_df["gene_biotype"] = result_df["source"]
             if "transcript_biotype" not in column_names:
                 logging.info("Using column 'source' to replace missing 'transcript_biotype'")
-                result_df['transcript_biotype'] = result_df['source']
-                
+                result_df["transcript_biotype"] = result_df["source"]
+
     if usecols is not None:
         column_names = set(result_df.columns)
         valid_columns = [c for c in usecols if c in column_names]

{gtfparse-2.6.2 → gtfparse-2.7.0}/gtfparse.egg-info/PKG-INFO

@@ -1,23 +1,33 @@
 Metadata-Version: 2.4
 Name: gtfparse
-Version: 2.6.2
+Version: 2.7.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
+Project-URL: Bug Tracker, https://github.com/openvax/gtfparse/issues
 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: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: polars>=0.20.2
 Requires-Dist: pyarrow>=18.0.0
 Requires-Dist: pandas>=2.1.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: coveralls; extra == "dev"
 Dynamic: license-file
 
 [![Tests](https://github.com/openvax/gtfparse/actions/workflows/tests.yml/badge.svg)](https://github.com/openvax/gtfparse/actions/workflows/tests.yml)

{gtfparse-2.6.2 → gtfparse-2.7.0}/gtfparse.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ gtfparse/../requirements.txt
 tests/test_create_missing_features.py
 tests/test_ensembl_gtf.py
 tests/test_expand_attributes.py
+tests/test_gencode_gtf.py
 tests/test_multiple_values_for_tag_attribute.py
 tests/test_parse_gtf_lines.py
 tests/test_read_stringtie_gtf.py

{gtfparse-2.6.2 → gtfparse-2.7.0}/gtfparse.egg-info/requires.txt

@@ -1,3 +1,9 @@
 polars>=0.20.2
 pyarrow>=18.0.0
 pandas>=2.1.0
+
+[dev]
+pytest
+pytest-cov
+ruff
+coveralls