feat: Add fromCsv function.

Author: mchav

dataframe.cabal

@@ -249,6 +249,7 @@ test-suite tests
                    Functions,
                    GenDataFrame,
                    Internal.Parsing,
+                   IO.CSV,
                    IO.JSON,
                    Operations.Aggregations,
                    Operations.Apply,

src/DataFrame.hs

@@ -250,6 +250,8 @@ import DataFrame.IO.CSV as CSV (
     ReadOptions (..),
     TypeSpec (..),
     defaultReadOptions,
+    fromCsv,
+    fromCsvBytes,
     readCsv,
     readCsvWithOpts,
     readSeparated,

src/DataFrame/IO/CSV.hs

@@ -27,6 +27,7 @@ import Data.Csv.Streaming (Records (..))
 import qualified Data.Csv.Streaming as CsvStream
 
 import Control.DeepSeq
+import Control.Exception (SomeException, catch)
 import Control.Monad
 import Data.Char
 import qualified Data.Csv as Csv
@@ -547,6 +548,17 @@ writeSeparated ::
     IO ()
 writeSeparated c filepath df = TIO.writeFile filepath (toSeparated c df)
 
+-- | Parse a CSV string into a DataFrame using default options.
+fromCsv :: String -> IO (Either String DataFrame)
+fromCsv s = do
+    let bs = BL.fromStrict (TE.encodeUtf8 (T.pack s))
+    (Right <$> decodeSeparated defaultReadOptions bs)
+        `catch` (\(e :: SomeException) -> pure (Left (show e)))
+
+-- | Parse a lazy 'ByteString' containing CSV data into a DataFrame using default options.
+fromCsvBytes :: BL.ByteString -> IO DataFrame
+fromCsvBytes = decodeSeparated defaultReadOptions
+
 stripQuotes :: T.Text -> T.Text
 stripQuotes txt =
     case T.uncons txt of

tests/IO/CSV.hs

@@ -0,0 +1,92 @@
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeApplications #-}
+
+module IO.CSV where
+
+import qualified Data.ByteString.Lazy as BL
+import qualified Data.Text as T
+import qualified Data.Text.Encoding as TE
+import qualified DataFrame as D
+import qualified DataFrame.Internal.Column as DI
+import DataFrame.Internal.DataFrame (DataFrame (..), toCsv)
+import DataFrame.IO.CSV (fromCsv, fromCsvBytes)
+import qualified DataFrame.Operations.Core as D
+import Test.HUnit (
+    Test (TestCase, TestLabel),
+    assertEqual,
+    assertFailure,
+ )
+
+-- | Happy path: parse a simple CSV string with Int and Text columns.
+fromCsvHappyPath :: Test
+fromCsvHappyPath = TestLabel "fromCsv_happy_path" $ TestCase $ do
+    result <- fromCsv "name,age\nAlice,30\nBob,25\nCharlie,35\n"
+    case result of
+        Left err -> assertFailure $ "Unexpected Left: " ++ err
+        Right df -> do
+            assertEqual "rows" 3 (D.nRows df)
+            assertEqual "columns" 2 (D.nColumns df)
+
+-- | Empty input should return a Left.
+fromCsvEmpty :: Test
+fromCsvEmpty = TestLabel "fromCsv_empty" $ TestCase $ do
+    result <- fromCsv ""
+    case result of
+        Left _ -> return ()
+        Right _ -> assertFailure "Expected Left for empty input"
+
+-- | fromCsvBytes happy path.
+fromCsvBytesHappyPath :: Test
+fromCsvBytesHappyPath = TestLabel "fromCsvBytes_happy_path" $ TestCase $ do
+    let bs = BL.fromStrict (TE.encodeUtf8 "x,y\n1,2\n3,4\n")
+    df <- fromCsvBytes bs
+    assertEqual "rows" 2 (D.nRows df)
+    assertEqual "columns" 2 (D.nColumns df)
+
+-- | Round trip: toCsv then fromCsv preserves data.
+fromCsvRoundTrip :: Test
+fromCsvRoundTrip = TestLabel "fromCsv_roundTrip" $ TestCase $ do
+    let df =
+            D.fromNamedColumns
+                [ ("a", DI.fromList @Int [1, 2, 3])
+                , ("b", DI.fromList @T.Text ["hello", "world", "test"])
+                ]
+    let csvString = T.unpack (toCsv df)
+    result <- fromCsv csvString
+    case result of
+        Left err -> assertFailure $ "Unexpected Left: " ++ err
+        Right df' -> do
+            assertEqual "round trip dimensions" (dataframeDimensions df) (dataframeDimensions df')
+            assertEqual "round trip data" df df'
+
+-- | Round trip via fromCsvBytes.
+fromCsvBytesRoundTrip :: Test
+fromCsvBytesRoundTrip = TestLabel "fromCsvBytes_roundTrip" $ TestCase $ do
+    let df =
+            D.fromNamedColumns
+                [ ("x", DI.fromList @Int [10, 20])
+                , ("y", DI.fromList @Double [1.5, 2.5])
+                ]
+    let bs = BL.fromStrict (TE.encodeUtf8 (toCsv df))
+    df' <- fromCsvBytes bs
+    assertEqual "round trip dimensions" (dataframeDimensions df) (dataframeDimensions df')
+
+-- | Single column CSV.
+fromCsvSingleColumn :: Test
+fromCsvSingleColumn = TestLabel "fromCsv_single_column" $ TestCase $ do
+    result <- fromCsv "id\n10\n20\n30\n"
+    case result of
+        Left err -> assertFailure $ "Unexpected Left: " ++ err
+        Right df -> do
+            assertEqual "rows" 3 (D.nRows df)
+            assertEqual "columns" 1 (D.nColumns df)
+
+tests :: [Test]
+tests =
+    [ fromCsvHappyPath
+    , fromCsvEmpty
+    , fromCsvBytesHappyPath
+    , fromCsvRoundTrip
+    , fromCsvBytesRoundTrip
+    , fromCsvSingleColumn
+    ]

tests/Main.hs

@@ -11,6 +11,7 @@ import Test.QuickCheck
 
 import qualified DecisionTree
 import qualified Functions
+import qualified IO.CSV
 import qualified IO.JSON
 import qualified Internal.Parsing
 import qualified LazyParquet
@@ -62,6 +63,7 @@ tests =
             ++ Operations.Take.tests
             ++ Operations.Typing.tests
             ++ Functions.tests
+            ++ IO.CSV.tests
             ++ IO.JSON.tests
             ++ Parquet.tests
             ++ LazyParquet.tests