dataframe.cabal

cabal-version:      3.4
name:               dataframe
version:            3.6.1.0
synopsis: A fast, safe, and intuitive DataFrame library.

description: A fast, safe, and intuitive DataFrame library for exploratory data analysis.

bug-reports: https://github.com/mchav/dataframe/issues
license:            MIT
license-file:       LICENSE
author:             Michael Chavinda
maintainer:         mschavinda@gmail.com

copyright: (c) 2024-2026 Michael Chavinda
category: Data
tested-with: GHC ==9.4.8 || ==9.6.7 || ==9.8.4 || ==9.10.3 || ==9.12.2
extra-doc-files: CHANGELOG.md README.md
extra-source-files: tests/data/typing/texts.txt
                    tests/data/typing/texts_with_empties.txt
                    tests/data/typing/texts_with_empties_and_nullish.txt
                    data/titanic/*.csv
                    data/ml/*.csv
                    data/ml/golden.json
                    data/sharded/*.parquet
                    tests/data/*.csv
                    tests/data/*.tsv
                    tests/data/*.parquet
                    tests/data/unstable_csv/*.csv
                    tests/data/unstable_csv/*.tsv
                    -- tests/data/*.md
                    -- tests/data/*.bin
                    -- tests/data/*.json
                    -- tests/data/*.txt
                    -- tests/data/*.encrypted

source-repository head
  type:     git
  location: https://github.com/mchav/dataframe

common warnings
    ghc-options:
        -Wall

flag no-csv
    default:     False
    manual:      True
    description: Exclude the CSV reader/writer (@dataframe-csv@). Enable
                 with @-f +no-csv@ (or @flags: no-csv@ in cabal.project)
                 to trim the dep set of the meta package when CSV is not
                 needed.

flag no-parquet
    default:     False
    manual:      True
    description: Exclude the Parquet reader/writer (@dataframe-parquet@
                 plus pinch, zstd, snappy). Enable with
                 @-f +no-parquet@. (Reading Parquet from HuggingFace lives
                 in the separate @dataframe-huggingface@ package, which is
                 not a dependency of this meta-package.)

flag no-th
    default:     False
    manual:      True
    description: Exclude the Template Haskell splices (@dataframe-th@,
                 @dataframe-csv-th@, @dataframe-parquet-th@). Enable
                 with @-f +no-th@ to drop the @template-haskell@ dep for
                 downstream packages that don't use compile-time schema
                 derivation.

library
    import: warnings
    default-extensions: Strict
    -- Lock the unused-packages gate locally; haskell-ci already runs the
    -- same Werror against this stanza. Catches the case where a satellite
    -- gets added to build-depends but never re-exported.
    ghc-options: -Werror=unused-packages
    exposed-modules: DataFrame,
                    DataFrame.Typed
    reexported-modules: DataFrame.Functions,
                        DataFrame.Synthesis,
                        DataFrame.Display.Web.Plot,
                        DataFrame.Display.Web.Chart,
                        DataFrame.Display.Web.Chart.Typed,
                        DataFrame.Core,
                        DataFrame.Schema,
                        DataFrame.Errors,
                        DataFrame.Operations.Core,
                        DataFrame.Operations.Join,
                        DataFrame.Operations.Merge,
                        DataFrame.Expression.Operators,
                        DataFrame.Operations.Permutation,
                        DataFrame.Operations.Subset,
                        DataFrame.Operations.Statistics,
                        DataFrame.Operations.Transformations,
                        DataFrame.Operations.Typing,
                        DataFrame.Operations.Aggregation,
                        DataFrame.Display,
                        DataFrame.Display.Terminal.Plot,
                        DataFrame.Monad,
                        DataFrame.DecisionTree,
                        DataFrame.Model,
                        DataFrame.ModelSelection,
                        DataFrame.LinearModel,
                        DataFrame.LinearModel.Regression,
                        DataFrame.LinearModel.Logistic,
                        DataFrame.Segmented,
                        DataFrame.SVM,
                        DataFrame.KMeans,
                        DataFrame.PCA,
                        DataFrame.DBSCAN,
                        DataFrame.GMM,
                        DataFrame.Boosting,
                        DataFrame.Boosting.GBM,
                        DataFrame.Boosting.AdaBoost,
                        DataFrame.Metrics,
                        DataFrame.IO.JSON,
                        DataFrame.Expr.Serialize,
                        DataFrame.IR.ExprJson,
                        DataFrame.Typed.Types,
                        DataFrame.Typed.Schema,
                        DataFrame.Typed.Freeze,
                        DataFrame.Typed.Access,
                        DataFrame.Typed.Operations,
                        DataFrame.Typed.Join,
                        DataFrame.Typed.Aggregate,
                        DataFrame.Typed.Expr,
                        DataFrame.Typed.Record,
                        DataFrame.Typed.Generic
    build-depends:    base >= 4 && <5,
                      dataframe-core >= 2.5 && < 2.6,
                      dataframe-json >= 1.2.0.1 && < 1.3,
                      dataframe-expr-serializer >= 1.2.1 && < 1.3,
                      dataframe-operations >= 2.5 && < 2.6,
                      dataframe-parsing >= 2.2 && < 2.3,
                      dataframe-viz >= 1.3.2 && < 1.4,
                      dataframe-learn >= 2.4.2 && < 2.5

    if !flag(no-csv)
        reexported-modules: DataFrame.IO.CSV,
                            DataFrame.Typed.IO.CSV
        build-depends:   dataframe-csv >= 2.3 && < 2.4
        cpp-options:     -DWITH_CSV

    if !flag(no-parquet)
        reexported-modules: DataFrame.IO.Parquet,
                            DataFrame.IO.Parquet.Binary,
                            DataFrame.IO.Parquet.Dictionary,
                            DataFrame.IO.Parquet.Levels,
                            DataFrame.IO.Parquet.Thrift,
                            DataFrame.IO.Parquet.Decompress,
                            DataFrame.IO.Parquet.Encoding,
                            DataFrame.IO.Parquet.Page,
                            DataFrame.IO.Parquet.Schema,
                            DataFrame.IO.Parquet.Utils,
                            DataFrame.IO.Parquet.Writer,
                            DataFrame.IO.Parquet.Seeking,
                            DataFrame.IO.Parquet.Time,
                            DataFrame.IO.Utils.RandomAccess,
                            DataFrame.Typed.IO.Parquet
        build-depends:   dataframe-parquet >= 1.5.0.1 && < 1.6
        cpp-options:     -DWITH_PARQUET

    -- The lazy executor calls both CSV and Parquet readers directly, so
    -- it can only be pulled in when both backends are present.
    if !flag(no-csv) && !flag(no-parquet)
        reexported-modules: DataFrame.Lazy,
                            DataFrame.Lazy.IO.Binary,
                            DataFrame.Lazy.IO.CSV,
                            DataFrame.Typed.Lazy
        build-depends:   dataframe-lazy >= 2.4.1 && < 2.5
        cpp-options:     -DWITH_LAZY

    if !flag(no-th)
        build-depends:   dataframe-th >= 2.3 && < 2.4
        cpp-options:     -DWITH_TH
        exposed-modules: DataFrame.TH,
                         DataFrame.Typed.TH

    if !flag(no-th) && !flag(no-csv)
        build-depends:   dataframe-csv-th >= 1.4 && < 1.5
        cpp-options:     -DWITH_CSV_TH

    if !flag(no-th) && !flag(no-parquet)
        build-depends:   dataframe-parquet-th >= 1.4 && < 1.5
        cpp-options:     -DWITH_PARQUET_TH

    hs-source-dirs:   src
    default-language: Haskell2010

executable dataframe-benchmark-example
    import: warnings
    main-is: Benchmark.hs
    build-depends:    base >= 4 && < 5,
                      dataframe >= 3.6 && < 3.7,
                      dataframe-operations >= 2.5 && < 2.6,
                      random >= 1 && < 2,
                      time >= 1.12 && < 2,
                      vector >= 0.13 && < 0.15,
    hs-source-dirs:   app
    default-language: Haskell2010
    ghc-options: -rtsopts -threaded -with-rtsopts=-N

executable synthesis
    import: warnings
    main-is: Synthesis.hs
    build-depends:    base >= 4 && < 5,
                      dataframe >= 3.6 && < 3.7,
                      dataframe-core >= 2.5 && < 2.6,
                      dataframe-learn >= 2.4.2 && < 2.5,
                      dataframe-operations >= 2.5 && < 2.6,
                      random >= 1 && < 2,
                      text >= 2.1 && < 3
    hs-source-dirs:   app
    default-language: Haskell2010
    ghc-options: -rtsopts -threaded -with-rtsopts=-N

executable dataframe
    import: warnings
    main-is: Main.hs
    build-depends:    base >= 4 && < 5,
                      directory >= 1.3.0.0 && < 2,
                      filepath >= 1.4 && < 2,
                      process >= 1.6 && < 2,
                      time >= 1.12 && < 2
    if !os(windows)
        build-depends: unix >= 2 && < 3
    hs-source-dirs:   app
    default-language: Haskell2010
    ghc-options: -rtsopts -threaded -with-rtsopts=-N

executable lazy-bench
    import: warnings
    main-is: LazyBenchmark.hs
    -- lazy-bench drives the lazy executor against CSV/Parquet sources, so
    -- it can only build when both backends are present.
    if flag(no-csv) || flag(no-parquet)
        buildable: False
    build-depends:    base >= 4 && < 5,
                      bytestring >= 0.11 && < 0.14,
                      containers >= 0.6.7 && < 0.10,
                      dataframe >= 3.6 && < 3.7,
                      dataframe-core >= 2.5 && < 2.6,
                      dataframe-lazy >= 2.4.1 && < 2.5,
                      dataframe-parsing >= 2.2 && < 2.3,
                      directory >= 1.3.0.0 && < 2,
                      random >= 1 && < 2,
                      text >= 2.1 && < 3,
                      time >= 1.12 && < 2,
    hs-source-dirs:   app
    default-language: Haskell2010
    ghc-options: -rtsopts -threaded -with-rtsopts=-N

benchmark dataframe-benchmark
    import: warnings
    type: exitcode-stdio-1.0
    main-is: Main.hs
    hs-source-dirs: benchmark
    build-depends: base >= 4 && < 5,
                   criterion >= 1 && < 2,
                   deepseq >= 1.4 && < 2,
                   process >= 1.6 && < 2,
                   dataframe >= 3.6 && < 3.7,
                   dataframe-core >= 2.5 && < 2.6,
                   dataframe-operations >= 2.5 && < 2.6,
                   random >= 1 && < 2,
    default-language: Haskell2010
    ghc-options:
      -threaded
      -rtsopts
      -with-rtsopts=-N

test-suite tests
    import: warnings
    type: exitcode-stdio-1.0
    main-is: Main.hs
    -- Threaded RTS with -N so the parallel-grouping parity test exercises the
    -- real multi-capability fork path rather than the sequential fallback.
    ghc-options: -threaded -rtsopts -with-rtsopts=-N
    -- The test runner imports CSV, JSON, Parquet, Lazy, and TH-derived
    -- schema modules. All features must be enabled for it to compile.
    if flag(no-csv) || flag(no-parquet) || flag(no-th)
        buildable: False
    other-modules: Assertions,
                   Functions,
                   GenDataFrame,
                   Internal.ColumnBuilder,
                   Internal.DictEncode,
                   Internal.Markdown,
                   Internal.PackedText,
                   Internal.Parsing,
                   PackedTextMigration,
                   PrettyPrint,
                   Learn.Denotation,
                   Learn.Models,
                   Learn.TypedModel,
                   Learn.Segmented,
                   Learn.Ensembles,
                   Learn.SklearnParity,
                   Learn.Synthesis,
                   Learn.MetricsTests,
                   Operations.ExprParse,
                   Learn.Metamorphic,
                   IO.CSV,
                   IO.CsvGolden,
                   IO.JSON,
                   IR.ExprJsonRoundtrip,
                   Operations.Aggregations,
                   Operations.CountDistinct,
                   Operations.SortMask,
                   Operations.TextKernels,
                   Operations.TopBy,
                   Operations.Apply,
                   Operations.Core,
                   Operations.Derive,
                   Operations.Filter,
                   Operations.GroupBy,
                   Operations.ParallelGroupBy,
                   Operations.ParallelJoin,
                   Operations.Inference,
                   Operations.InsertColumn,
                   Operations.Join,
                   Operations.Merge,
                   Operations.Nullable,
                   Operations.NullableHashing,
                   Operations.Provenance,
                   Operations.ReadCsv,
                   Operations.Window,
                   Operations.WriteCsv,
                   Operations.Shuffle,
                   Operations.Sort,
                   Operations.SetOps,
                   Operations.Subset,
                   Operations.Statistics,
                   Operations.Take,
                   Operations.Typing,
                   Operations.VectorKernel,
                   Operations.InterpreterKernels,
                   Operations.MonomorphicLoops,
                   Operations.RowWise,
                   Operations.Record,
                   LazyParquet,
                   LazyParity,
                   LazyProjection,
                   Parquet,
                   ParquetTestData,
                   Plotting,
                   Properties,
                   Properties.Categorical,
                   Simplify,
                   Typed.Parity,
                   Typed.IOReaders,
                   Monad
    build-depends:  base >= 4 && < 5,
                    aeson >= 0.11.0.0 && < 3,
                    bytestring >= 0.11 && < 0.14,
                    dataframe >= 3.6 && < 3.7,
                    dataframe-core >= 2.5 && < 2.6,
                    dataframe-core >= 2.5 && < 2.6,
                    dataframe-csv >= 2.3 && < 2.4,
                    dataframe-expr-serializer >= 1.2.1 && < 1.3,
                    dataframe-fastcsv >= 1.4.0.1 && < 1.5,
                    dataframe-json >= 1.2.0.1 && < 1.3,
                    dataframe-lazy >= 2.4.1 && < 2.5,
                    dataframe-learn >= 2.4.2 && < 2.5,
                    dataframe-operations >= 2.5 && < 2.6,
                    dataframe-parquet >= 1.5.0.1 && < 1.6,
                    dataframe-parsing >= 2.2 && < 2.3,
                    HUnit >= 1.6 && < 1.8,
                    QuickCheck >= 2 && < 3,
                    random-shuffle >= 0.0.4 && < 1,
                    random >= 1 && < 2,
                    text >= 2.1 && < 3,
                    time >= 1.12 && < 2,
                    vector >= 0.13 && < 0.15,
                    temporary >= 1.3 && < 1.5,
                    directory >= 1.3 && < 1.4,
                    containers >= 0.6.7 && < 0.10
    hs-source-dirs: tests
    default-language: Haskell2010

-- Focused oracle for the packed-text column variant. Kept as its own suite so
-- it can run independently of the (heavier) `tests` runner.
test-suite packed-text
    import: warnings
    type: exitcode-stdio-1.0
    main-is: PackedTextMain.hs
    if flag(no-csv) || flag(no-parquet) || flag(no-th)
        buildable: False
    other-modules: Internal.PackedText
    build-depends:  base >= 4 && < 5,
                    bytestring >= 0.11 && < 0.14,
                    dataframe >= 3.6 && < 3.7,
                    dataframe-core >= 2.5 && < 2.6,
                    dataframe-operations >= 2.5 && < 2.6,
                    HUnit >= 1.6 && < 1.8,
                    text >= 2.1 && < 3,
                    vector >= 0.13 && < 0.15
    hs-source-dirs: tests
    default-language: Haskell2010