diff --git a/fasta.cabal b/fasta.cabal --- a/fasta.cabal +++ b/fasta.cabal @@ -10,7 +10,7 @@ -- PVP summary: +-+------- breaking API changes -- | | +----- non-breaking API additions -- | | | +--- code changes with no API change -version: 0.8.0.2 +version: 0.9.0.0 -- A short (one-line) description of the package. synopsis: A simple, mindless parser for fasta files. @@ -82,6 +82,8 @@ , pipes-group >= 1.0 , pipes-text >= 0.0 , pipes-bytestring >= 2.1 + , attoparsec + , pipes-attoparsec , lens >= 4.9 , foldl >= 1.0 diff --git a/src/Data/Fasta/ByteString/Lazy/Parse.hs b/src/Data/Fasta/ByteString/Lazy/Parse.hs --- a/src/Data/Fasta/ByteString/Lazy/Parse.hs +++ b/src/Data/Fasta/ByteString/Lazy/Parse.hs @@ -8,27 +8,34 @@ {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE BangPatterns #-} -module Data.Fasta.ByteString.Lazy.Parse ( parseFasta - , parseCLIPFasta +module Data.Fasta.ByteString.Lazy.Parse ( parsecFasta + , parsecCLIPFasta + , attoFasta + , attoCLIPFasta , pipesFasta + , pipesCLIPFasta , removeNs , removeN , removeCLIPNs ) where -- Built-in import Data.Char -import Control.Monad (void) import Text.Parsec import Text.Parsec.ByteString.Lazy import qualified Data.Map.Strict as Map +import qualified Data.ByteString as BW import qualified Data.ByteString.Char8 as SB import qualified Data.ByteString.Lazy.Char8 as B +import qualified Control.Applicative as CA +import Control.Monad (void) -- Cabal +import qualified Data.Attoparsec.ByteString.Char8 as A import Pipes import qualified Pipes.Prelude as P import qualified Pipes.ByteString as PB import qualified Pipes.Group as PG +import qualified Pipes.Attoparsec as PA import Control.Lens (view) import qualified Control.Foldl as FL @@ -71,27 +78,86 @@ spaces many fastaCLIP --- | Parse a standard fasta file into lazy text sequences -parseFasta :: B.ByteString -> [FastaSequence] -parseFasta = eToV . parse fastaFile "error" +-- | Parse a standard fasta file into +parsecFasta :: B.ByteString -> [FastaSequence] +parsecFasta = eToV . parse fastaFile "error" where eToV (Right x) = x eToV (Left x) = error ("Unable to parse fasta file\n" ++ show x) --- | Parse a CLIP fasta file into lazy text sequences -parseCLIPFasta :: B.ByteString -> CloneMap -parseCLIPFasta = Map.fromList - . map (\(!x, (!y, !z)) -> ((x, y), z)) - . zip [0..] - . eToV - . parse fastaCLIPFile "error" +-- | Parse a CLIP fasta file into +parsecCLIPFasta :: B.ByteString -> CloneMap +parsecCLIPFasta = Map.fromList + . map (\(!x, (!y, !z)) -> ((x, y), z)) + . zip [0..] + . eToV + . parse fastaCLIPFile "error" where eToV (Right x) = x eToV (Left x) = error ("Unable to parse fasta file\n" ++ show x) --- | Parse a standard fasta file into strict text sequences for pipes. This is --- the highly recommeded way of parsing, as it is computationally fast and --- uses memory based on line length +-- | attopares any char but space +anyButSpace :: A.Parser Char +anyButSpace = do + A.skipSpace + x <- A.letter_ascii + A.skipSpace + return x + +-- | attoparsec parser for a fasta type +fasta' :: A.Parser FastaSequence +fasta' = do + header <- A.takeWhile (\x -> x /= '\n' && x /= '\r') + A.endOfLine + fseq <- A.manyTill anyButSpace (void (A.char '>') CA.<|> A.endOfInput) + return FastaSequence { fastaHeader = B.fromStrict header + , fastaSeq = B.pack fseq } + +-- | attoparsec parser for a fasta file +fastaFile' :: A.Parser [FastaSequence] +fastaFile' = do + A.skipSpace + A.char '>' + A.many' fasta' + +-- | attoparsec parser for a CLIP fasta sequence +fastaCLIP' :: A.Parser FastaSequence +fastaCLIP' = do + header <- A.takeWhile (\x -> x /= '\n' && x /= '\r') + A.endOfLine + fseq <- A.manyTill anyButSpace (void (A.char '>') CA.<|> A.endOfInput) + return FastaSequence { fastaHeader = B.fromStrict header + , fastaSeq = B.pack fseq } + +clone' :: A.Parser (Germline, [FastaSequence]) +clone' = do + A.skipSpace + germline <- fastaCLIP' + fseqs <- A.manyTill fasta' (void (A.char '>') CA.<|> A.endOfInput) + return (germline, fseqs) + +-- | attoparsec parser for a fasta file +fastaCLIPFile' :: A.Parser [(Germline, [FastaSequence])] +fastaCLIPFile' = do + A.skipSpace + A.string ">>" + A.many' clone' + +-- | Parse a standard fasta file +attoFasta :: BW.ByteString -> [FastaSequence] +attoFasta = eToV . A.parseOnly fastaFile' + where + eToV (Right x) = x + eToV (Left x) = error ("Unable to parse fasta file\n" ++ show x) + +-- | Parse a CLIP fasta file into text sequences +attoCLIPFasta :: BW.ByteString -> [(Germline, [FastaSequence])] +attoCLIPFasta = eToV . A.parseOnly fastaCLIPFile' + where + eToV (Right x) = x + eToV (Left x) = error ("Unable to parse fasta file\n" ++ show x) + +-- | Parse a standard fasta file into a pipe pipesFasta :: (MonadIO m) => Producer SB.ByteString m () -> Producer FastaSequence m () @@ -111,6 +177,14 @@ . tail . SB.lines $ x } + +-- | Parse a CLIP fasta file into strict text sequences for pipes. +pipesCLIPFasta :: (MonadIO m) + => Producer BW.ByteString m () + -> Producer (Germline, [FastaSequence]) m (Either (PA.ParsingError, Producer BW.ByteString m ()) ()) +pipesCLIPFasta = PA.parsed clone' + . PB.drop 2 + . PB.dropWhile (`BW.elem` "\n\r\t ") -- | Remove Ns from a collection of sequences removeNs :: [FastaSequence] -> [FastaSequence] diff --git a/src/Data/Fasta/ByteString/Parse.hs b/src/Data/Fasta/ByteString/Parse.hs --- a/src/Data/Fasta/ByteString/Parse.hs +++ b/src/Data/Fasta/ByteString/Parse.hs @@ -8,9 +8,12 @@ {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE BangPatterns #-} -module Data.Fasta.ByteString.Parse ( parseFasta - , parseCLIPFasta +module Data.Fasta.ByteString.Parse ( parsecFasta + , parsecCLIPFasta + , attoFasta + , attoCLIPFasta , pipesFasta + , pipesCLIPFasta , removeNs , removeN , removeCLIPNs ) where @@ -20,13 +23,18 @@ import Text.Parsec import Text.Parsec.ByteString import qualified Data.Map.Strict as Map +import qualified Data.ByteString as BW import qualified Data.ByteString.Char8 as B +import qualified Control.Applicative as CA +import Control.Monad (void) -- Cabal +import qualified Data.Attoparsec.ByteString.Char8 as A import Pipes import qualified Pipes.Prelude as P import qualified Pipes.ByteString as PB import qualified Pipes.Group as PG +import qualified Pipes.Attoparsec as PA import Control.Lens (view) import qualified Control.Foldl as FL @@ -69,23 +77,84 @@ many fastaCLIP -- | Parse a standard fasta file into text sequences -parseFasta :: B.ByteString -> [FastaSequence] -parseFasta = eToV . parse fastaFile "error" +parsecFasta :: B.ByteString -> [FastaSequence] +parsecFasta = eToV . parse fastaFile "error" where eToV (Right x) = x eToV (Left x) = error ("Unable to parse fasta file\n" ++ show x) -- | Parse a CLIP fasta file into text sequences -parseCLIPFasta :: B.ByteString -> CloneMap -parseCLIPFasta = Map.fromList - . map (\(!x, (!y, !z)) -> ((x, y), z)) - . zip [0..] - . eToV - . parse fastaCLIPFile "error" +parsecCLIPFasta :: B.ByteString -> CloneMap +parsecCLIPFasta = Map.fromList + . map (\(!x, (!y, !z)) -> ((x, y), z)) + . zip [0..] + . eToV + . parse fastaCLIPFile "error" where eToV (Right x) = x eToV (Left x) = error ("Unable to parse fasta file\n" ++ show x) +-- | attopares any char but space +anyButSpace :: A.Parser Char +anyButSpace = do + A.skipSpace + x <- A.letter_ascii + A.skipSpace + return x + +-- | attoparsec parser for a fasta type +fasta' :: A.Parser FastaSequence +fasta' = do + header <- A.takeWhile (\x -> x /= '\n' && x /= '\r') + A.endOfLine + fseq <- A.manyTill anyButSpace (void (A.char '>') CA.<|> A.endOfInput) + return FastaSequence { fastaHeader = header + , fastaSeq = B.pack fseq } + +-- | attoparsec parser for a fasta file +fastaFile' :: A.Parser [FastaSequence] +fastaFile' = do + A.skipSpace + A.char '>' + A.many' fasta' + +-- | attoparsec parser for a CLIP fasta sequence +fastaCLIP' :: A.Parser FastaSequence +fastaCLIP' = do + header <- A.takeWhile (\x -> x /= '\n' && x /= '\r') + A.endOfLine + fseq <- A.manyTill anyButSpace (void (A.char '>') CA.<|> A.endOfInput) + return FastaSequence { fastaHeader = header + , fastaSeq = B.pack fseq } + +clone' :: A.Parser (Germline, [FastaSequence]) +clone' = do + A.skipSpace + germline <- fastaCLIP' + fseqs <- A.manyTill fasta' (void (A.char '>') CA.<|> A.endOfInput) + return (germline, fseqs) + +-- | attoparsec parser for a fasta file +fastaCLIPFile' :: A.Parser [(Germline, [FastaSequence])] +fastaCLIPFile' = do + A.skipSpace + A.string ">>" + A.many' clone' + +-- | Parse a standard fasta file +attoFasta :: B.ByteString -> [FastaSequence] +attoFasta = eToV . A.parseOnly fastaFile' + where + eToV (Right x) = x + eToV (Left x) = error ("Unable to parse fasta file\n" ++ show x) + +-- | Parse a CLIP fasta file into text sequences +attoCLIPFasta :: B.ByteString -> [(Germline, [FastaSequence])] +attoCLIPFasta = eToV . A.parseOnly fastaCLIPFile' + where + eToV (Right x) = x + eToV (Left x) = error ("Unable to parse fasta file\n" ++ show x) + -- | Parse a standard fasta file into strict text sequences for pipes. This is -- the highly recommeded way of parsing, as it is computationally fast and -- uses memory based on line length @@ -101,6 +170,14 @@ where toFasta x = FastaSequence { fastaHeader = head . B.lines $ x , fastaSeq = B.concat . tail . B.lines $ x } + +-- | Parse a CLIP fasta file into strict text sequences for pipes. +pipesCLIPFasta :: (MonadIO m) + => Producer B.ByteString m () + -> Producer (Germline, [FastaSequence]) m (Either (PA.ParsingError, Producer B.ByteString m ()) ()) +pipesCLIPFasta = PA.parsed clone' + . PB.drop 2 + . PB.dropWhile (`BW.elem` "\n\r\t ") -- | Remove Ns from a collection of sequences removeNs :: [FastaSequence] -> [FastaSequence] diff --git a/src/Data/Fasta/Text/Lazy/Parse.hs b/src/Data/Fasta/Text/Lazy/Parse.hs --- a/src/Data/Fasta/Text/Lazy/Parse.hs +++ b/src/Data/Fasta/Text/Lazy/Parse.hs @@ -1,5 +1,5 @@ -- Parse module. --- By G.W. Schwartz +-- By Gregory W. Schwartz -- {- | Collection of functions for the parsing of a fasta file. Uses the lazy Text type. @@ -8,9 +8,12 @@ {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE BangPatterns #-} -module Data.Fasta.Text.Lazy.Parse ( parseFasta - , parseCLIPFasta +module Data.Fasta.Text.Lazy.Parse ( parsecFasta + , parsecCLIPFasta + , attoFasta + , attoCLIPFasta , pipesFasta + , pipesCLIPFasta , removeNs , removeN , removeCLIPNs ) where @@ -23,12 +26,15 @@ import qualified Data.Map.Strict as Map import qualified Data.Text as ST import qualified Data.Text.Lazy as T +import qualified Control.Applicative as CA -- Cabal +import qualified Data.Attoparsec.Text as A import Pipes import qualified Pipes.Prelude as P import qualified Pipes.Text as PT import qualified Pipes.Group as PG +import qualified Pipes.Attoparsec as PA import Control.Lens (view) import qualified Control.Foldl as FL @@ -71,16 +77,16 @@ spaces many fastaCLIP --- | Parse a standard fasta file into lazy text sequences -parseFasta :: T.Text -> [FastaSequence] -parseFasta = eToV . parse fastaFile "error" +-- | Parse a standard fasta file +parsecFasta :: T.Text -> [FastaSequence] +parsecFasta = eToV . parse fastaFile "error" where eToV (Right x) = x eToV (Left x) = error ("Unable to parse fasta file\n" ++ show x) --- | Parse a CLIP fasta file into lazy text sequences -parseCLIPFasta :: T.Text -> CloneMap -parseCLIPFasta = Map.fromList +-- | Parse a CLIP fasta file +parsecCLIPFasta :: T.Text -> CloneMap +parsecCLIPFasta = Map.fromList . map (\(!x, (!y, !z)) -> ((x, y), z)) . zip [0..] . eToV @@ -89,9 +95,68 @@ eToV (Right x) = x eToV (Left x) = error ("Unable to parse fasta file\n" ++ show x) --- | Parse a standard fasta file into strict text sequences for pipes. This is --- the highly recommeded way of parsing, as it is computationally fast and --- uses memory based on line length +-- | attopares any char but space +anyButSpace :: A.Parser Char +anyButSpace = do + A.skipSpace + x <- A.letter + A.skipSpace + return x + +-- | attoparsec parser for a fasta type +fasta' :: A.Parser FastaSequence +fasta' = do + header <- A.takeWhile (not . A.isEndOfLine) + A.endOfLine + fseq <- A.manyTill anyButSpace (void (A.char '>') CA.<|> A.endOfInput) + return FastaSequence { fastaHeader = T.fromStrict header + , fastaSeq = T.pack fseq } + +-- | attoparsec parser for a fasta file +fastaFile' :: A.Parser [FastaSequence] +fastaFile' = do + A.skipSpace + A.char '>' + A.many' fasta' + +-- | attoparsec parser for a CLIP fasta sequence +fastaCLIP' :: A.Parser FastaSequence +fastaCLIP' = do + header <- A.takeWhile (not . A.isEndOfLine) + A.endOfLine + fseq <- A.manyTill anyButSpace (void (A.char '>') CA.<|> A.endOfInput) + return FastaSequence { fastaHeader = T.fromStrict header + , fastaSeq = T.pack fseq } + +clone' :: A.Parser (Germline, [FastaSequence]) +clone' = do + A.skipSpace + germline <- fastaCLIP' + fseqs <- A.manyTill fasta' (void (A.char '>') CA.<|> A.endOfInput) + return (germline, fseqs) + +-- | attoparsec parser for a fasta file +fastaCLIPFile' :: A.Parser [(Germline, [FastaSequence])] +fastaCLIPFile' = do + A.skipSpace + A.string ">>" + A.many' clone' + +-- | Parse a standard fasta file +attoFasta :: ST.Text -> [FastaSequence] +attoFasta = eToV . A.parseOnly fastaFile' + where + eToV (Right x) = x + eToV (Left x) = error ("Unable to parse fasta file\n" ++ show x) + +-- | Parse a CLIP fasta file +attoCLIPFasta :: ST.Text -> [(Germline, [FastaSequence])] +attoCLIPFasta = eToV . A.parseOnly fastaCLIPFile' + where + eToV (Right x) = x + eToV (Left x) = error ("Unable to parse fasta file\n" ++ show x) + +-- | Parse a standard fasta file into a pipe pipesFasta :: (MonadIO m) => Producer ST.Text m () -> Producer FastaSequence m () @@ -108,6 +173,12 @@ . tail . ST.lines $ x } + +-- | Parse a CLIP fasta file into a pipe +pipesCLIPFasta :: (MonadIO m) + => Producer ST.Text m () + -> Producer (Germline, [FastaSequence]) m (Either (PA.ParsingError, Producer ST.Text m ()) ()) +pipesCLIPFasta = PA.parsed clone' . PT.drop 2 . (>-> PT.stripStart) -- | Remove Ns from a collection of sequences removeNs :: [FastaSequence] -> [FastaSequence] diff --git a/src/Data/Fasta/Text/Parse.hs b/src/Data/Fasta/Text/Parse.hs --- a/src/Data/Fasta/Text/Parse.hs +++ b/src/Data/Fasta/Text/Parse.hs @@ -8,9 +8,12 @@ {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE BangPatterns #-} -module Data.Fasta.Text.Parse ( parseFasta - , parseCLIPFasta +module Data.Fasta.Text.Parse ( parsecFasta + , parsecCLIPFasta + , attoFasta + , attoCLIPFasta , pipesFasta + , pipesCLIPFasta , removeNs , removeN , removeCLIPNs ) where @@ -21,12 +24,16 @@ import Text.Parsec.Text import qualified Data.Map.Strict as Map import qualified Data.Text as T +import qualified Control.Applicative as CA +import Control.Monad (void) -- Cabal +import qualified Data.Attoparsec.Text as A import Pipes import qualified Pipes.Prelude as P import qualified Pipes.Text as PT import qualified Pipes.Group as PG +import qualified Pipes.Attoparsec as PA import Control.Lens (view) import qualified Control.Foldl as FL @@ -68,27 +75,86 @@ spaces many fastaCLIP --- | Parse a standard fasta file into text sequences -parseFasta :: T.Text -> [FastaSequence] -parseFasta = eToV . parse fastaFile "error" +-- | Parse a standard fasta file +parsecFasta :: T.Text -> [FastaSequence] +parsecFasta = eToV . parse fastaFile "error" where eToV (Right x) = x eToV (Left x) = error ("Unable to parse fasta file\n" ++ show x) --- | Parse a CLIP fasta file into text sequences -parseCLIPFasta :: T.Text -> CloneMap -parseCLIPFasta = Map.fromList - . map (\(!x, (!y, !z)) -> ((x, y), z)) - . zip [0..] - . eToV - . parse fastaCLIPFile "error" +-- | Parse a CLIP fasta file +parsecCLIPFasta :: T.Text -> CloneMap +parsecCLIPFasta = Map.fromList + . map (\(!x, (!y, !z)) -> ((x, y), z)) + . zip [0..] + . eToV + . parse fastaCLIPFile "error" where eToV (Right x) = x eToV (Left x) = error ("Unable to parse fasta file\n" ++ show x) --- | Parse a standard fasta file into strict text sequences for pipes. This is --- the highly recommeded way of parsing, as it is computationally fast and --- uses memory based on line length +-- | attopares any char but space +anyButSpace :: A.Parser Char +anyButSpace = do + A.skipSpace + x <- A.letter + A.skipSpace + return x + +-- | attoparsec parser for a fasta type +fasta' :: A.Parser FastaSequence +fasta' = do + header <- A.takeWhile (not . A.isEndOfLine) + A.endOfLine + fseq <- A.manyTill anyButSpace (void (A.char '>') CA.<|> A.endOfInput) + return FastaSequence { fastaHeader = header + , fastaSeq = T.pack fseq } + +-- | attoparsec parser for a fasta file +fastaFile' :: A.Parser [FastaSequence] +fastaFile' = do + A.skipSpace + A.char '>' + A.many' fasta' + +-- | attoparsec parser for a CLIP fasta sequence +fastaCLIP' :: A.Parser FastaSequence +fastaCLIP' = do + header <- A.takeWhile (not . A.isEndOfLine) + A.endOfLine + fseq <- A.manyTill anyButSpace (void (A.char '>') CA.<|> A.endOfInput) + return FastaSequence { fastaHeader = header + , fastaSeq = T.pack fseq } + +clone' :: A.Parser (Germline, [FastaSequence]) +clone' = do + A.skipSpace + germline <- fastaCLIP' + fseqs <- A.manyTill fasta' (void (A.char '>') CA.<|> A.endOfInput) + return (germline, fseqs) + +-- | attoparsec parser for a fasta file +fastaCLIPFile' :: A.Parser [(Germline, [FastaSequence])] +fastaCLIPFile' = do + A.skipSpace + A.string ">>" + A.many' clone' + +-- | Parse a standard fasta file +attoFasta :: T.Text -> [FastaSequence] +attoFasta = eToV . A.parseOnly fastaFile' + where + eToV (Right x) = x + eToV (Left x) = error ("Unable to parse fasta file\n" ++ show x) + +-- | Parse a CLIP fasta file +attoCLIPFasta :: T.Text -> [(Germline, [FastaSequence])] +attoCLIPFasta = eToV . A.parseOnly fastaCLIPFile' + where + eToV (Right x) = x + eToV (Left x) = error ("Unable to parse fasta file\n" ++ show x) + +-- | Parse a standard fasta file into a pipe pipesFasta :: (MonadIO m) => Producer T.Text m () -> Producer FastaSequence m () pipesFasta p = FL.purely PG.folds FL.mconcat ( view (PT.splits '>') . PT.drop (1 :: Int) @@ -97,6 +163,12 @@ where toFasta x = FastaSequence { fastaHeader = head . T.lines $ x , fastaSeq = T.concat . tail . T.lines $ x } + +-- | Parse a CLIP fasta file into a pipe +pipesCLIPFasta :: (MonadIO m) + => Producer T.Text m () + -> Producer (Germline, [FastaSequence]) m (Either (PA.ParsingError, Producer T.Text m ()) ()) +pipesCLIPFasta = PA.parsed clone' . PT.drop 2 . (>-> PT.stripStart) -- | Remove Ns from a collection of sequences removeNs :: [FastaSequence] -> [FastaSequence] diff --git a/src/Data/Fasta/Text/Types.hs b/src/Data/Fasta/Text/Types.hs --- a/src/Data/Fasta/Text/Types.hs +++ b/src/Data/Fasta/Text/Types.hs @@ -1,5 +1,5 @@ -- Types module. --- By G.W. Schwartz +-- By Gregory W. Schwartz -- {- | Collects all application specific types. Used here for Text. -}