cobot-io 0.1.2.0 → 0.1.2.1

raw patch · 15 files changed

+656/−238 lines, 15 filesdep +directorydep ~QuickCheckdep ~hspecPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: directory

Dependency ranges changed: QuickCheck, hspec

API changes (from Hackage documentation)

Files

• cobot-io.cabal +9/−4
• src/Bio/GB.hs +1/−2
• src/Bio/MAE.hs +24/−0
• src/Bio/MAE/Parser.hs +156/−0
• src/Bio/MAE/Type.hs +60/−0
• src/Bio/MMTF.hs +37/−30
• src/Bio/MMTF/Decode.hs +15/−15
• src/Bio/MMTF/Type.hs +37/−41
• src/Bio/PDB.hs +57/−1
• src/Bio/PDB/Type.hs +79/−116
• src/Bio/Structure.hs +32/−21
• test/FASTASpec.hs +6/−4
• test/MAEParserSpec.hs +136/−0
• test/MMTFSpec.hs +1/−1
• test/Spec.hs +6/−3

@@ -4,10 +4,10 @@ -- -- see: https://github.com/sol/hpack ----- hash: b952542571739fbdf02508e11db35e6059993b82d37e4f7e27825e5c83fedfb1+-- hash: 5649e9d10f32f2f4349434935511b7ca5b206829754168dd6c74817d422c0e91  name:           cobot-io-version:        0.1.2.0+version:        0.1.2.1 synopsis:       Biological data file formats and IO description:    Please see the README on GitHub at <https://github.com/less-wrong/cobot-io#readme> category:       Bio@@ -40,6 +40,9 @@       Bio.GB.Parser       Bio.GB.Type       Bio.GB.Writer+      Bio.MAE+      Bio.MAE.Parser+      Bio.MAE.Type       Bio.MMTF       Bio.MMTF.Decode       Bio.MMTF.Decode.Codec@@ -94,6 +97,7 @@       FastaWriterSpec       GBParserSpec       GBWriterSpec+      MAEParserSpec       MMTFSpec       SequenceSpec       UniprotSpec@@ -103,7 +107,7 @@   default-extensions: OverloadedStrings TypeFamilies   ghc-options: -threaded -rtsopts -with-rtsopts=-N   build-depends:-      QuickCheck >=2.9.2 && <2.13+      QuickCheck >=2.9.2 && <2.14     , array >=0.5 && <0.6     , attoparsec >=0.10 && <0.14     , base >=4.7 && <5@@ -113,7 +117,8 @@     , containers >=0.5.7.1 && <0.7     , data-msgpack >=0.0.9 && <0.1     , deepseq >=1.4 && <1.5-    , hspec >=2.4.1 && <2.7+    , directory+    , hspec >=2.4.1 && <2.8     , http-conduit >=2.3 && <2.4     , hyraxAbif >=0.2.3.15 && <0.2.4.0     , lens >=4.16 && <5.0

@@ -13,8 +13,7 @@ import           Control.Monad.IO.Class (MonadIO, liftIO) import           Data.Attoparsec.Text   (parseOnly) import           Data.Bifunctor         (first)-import           Data.Text              (Text)-import           Data.Text              (pack)+import           Data.Text              (Text, pack) import qualified Data.Text.IO           as TIO (readFile, writeFile)  -- | Reads 'GenBankSequence' from givem file.

@@ -0,0 +1,24 @@+module Bio.MAE+  ( module T+  , fromFile+  , fromText+  , maeP+  ) where++import           Bio.MAE.Parser+import           Bio.MAE.Type           as T+import           Control.Monad.IO.Class (MonadIO, liftIO)+import           Data.Attoparsec.Text   (parseOnly)+import           Data.Bifunctor         (first)+import           Data.Text              (Text, pack)+import qualified Data.Text.IO           as TIO (readFile)++-- | Reads 'Mae' from givem file.+--+fromFile :: MonadIO m => FilePath -> m Mae+fromFile f = liftIO (TIO.readFile f) >>= either fail pure . parseOnly maeP++-- | Reads 'Mae' from 'Text'.+--+fromText :: Text -> Either Text Mae+fromText = first pack . parseOnly maeP

@@ -0,0 +1,156 @@+{-# LANGUAGE TupleSections #-}++module Bio.MAE.Parser+  ( maeP+  , versionP+  , blockP+  , tableP+  ) where++import           Bio.MAE.Type         (Block (..), Mae (..), MaeValue (..),+                                       Table (..))+import           Control.Applicative  ((<|>))+import           Control.Monad        (replicateM, when, zipWithM)+import           Data.Attoparsec.Text (Parser, char, decimal, endOfInput,+                                       endOfLine, many', many1', string,+                                       takeWhile, takeWhile1)+import           Data.Char            (isSpace)+import           Data.List            (transpose)+import           Data.Map.Strict      (Map)+import qualified Data.Map.Strict      as M (fromList)+import           Data.Text            (Text)+import qualified Data.Text            as T (pack, uncons)+import qualified Data.Text.Read       as TR (decimal, rational, signed)+import           Prelude              hiding (takeWhile)++maeP :: Parser Mae+maeP = Mae <$> versionP+           <*> many' blockP+           <*  endOfInput++versionP :: Parser Text+versionP = inBrackets $  lineP+                      *> delimiterP+                      *> lineP++blockP :: Parser Block+blockP = uncurry <$> (Block <$> anyStringP <* many' oneSpaceP)+                 <*> inBrackets ((,) <$> fieldsP <*> many' tableP)+  where+    fieldsP :: Parser (Map Text MaeValue)+    fieldsP = do+        fieldNames  <- upToDelimiterP lineP+        fieldMaeValues <- replicateM (length fieldNames) lineP++        M.fromList <$> zipWithM (\k v -> (k,) <$> textToMaeValue k v) fieldNames fieldMaeValues++textToMaeValue :: Text -> Text -> Parser MaeValue+textToMaeValue k v = if v == absentMaeValue then pure Absent else+    case T.uncons k of+        Just (c, _) -> getMaeValueReader c v+        _           -> fail "Absent field name."+  where+    absentMaeValue :: Text+    absentMaeValue = "<>"++    getMaeValueReader :: Char -> Text -> Parser MaeValue+    getMaeValueReader 'i' = textToIntMaeValueReader+    getMaeValueReader 'r' = textToRealMaeValueReader+    getMaeValueReader 'b' = textToBoolMaeValueReader+    getMaeValueReader 's' = textToStringMaeValueReader+    getMaeValueReader _   = const $ fail "Unknown value type."++    textToIntMaeValueReader :: Text -> Parser MaeValue+    textToIntMaeValueReader = either fail (pure . IntMaeValue . fst) . TR.signed TR.decimal++    textToRealMaeValueReader :: Text -> Parser MaeValue+    textToRealMaeValueReader = either fail (pure . RealMaeValue . fst) . TR.signed TR.rational++    textToBoolMaeValueReader :: Text -> Parser MaeValue+    textToBoolMaeValueReader t =+        case t of+            "0" -> pure $ BoolMaeValue False+            "1" -> pure $ BoolMaeValue True+            _   -> fail "Can't parse bool value."++    textToStringMaeValueReader :: Text -> Parser MaeValue+    textToStringMaeValueReader = pure . StringMaeValue++tableP :: Parser Table+tableP = do+    name            <- many' oneSpaceP *> takeWhile1 (/= leftSquareBracket)+    numberOfEntries <- char leftSquareBracket *> decimal <* char rightSquareBracket++    _ <- many' oneSpaceP++    contents <- inBrackets $ do+        fieldNames  <- upToDelimiterP lineP+        let readers = fmap textToMaeValue fieldNames+        entries     <- replicateM numberOfEntries $ entryP readers++        delimiterP++        pure $ M.fromList $ zip fieldNames $ transpose entries++    pure $ Table name contents+  where+    leftSquareBracket :: Char+    leftSquareBracket = '['++    rightSquareBracket :: Char+    rightSquareBracket = ']'++    entryP :: [Text -> Parser MaeValue] -> Parser [MaeValue]+    entryP readers = do+        valuesT <- many1' (many' oneSpaceP *> valueTP <* many' oneSpaceP) <* tillEndOfLine+        when (length readers /= length valuesT - 1) $ fail "Wrong number of values in an entry."+        zipWithM ($) readers $ drop 1 valuesT++--------------------------------------------------------------------------------+-- Utility functions.+--------------------------------------------------------------------------------++inBrackets :: Parser a -> Parser a+inBrackets p =  char leftBracket *> many1' tillEndOfLine+             *> p+             <* many' oneSpaceP <* char rightBracket <* many1' tillEndOfLine+  where+    leftBracket :: Char+    leftBracket = '{'++    rightBracket :: Char+    rightBracket = '}'++delimiterP :: Parser ()+delimiterP = many' oneSpaceP *> string delimiter *> tillEndOfLine+  where+    delimiter :: Text+    delimiter = ":::"++upToDelimiterP :: Parser a -> Parser [a]+upToDelimiterP p = ([] <$ delimiterP) <|> ((:) <$> p <*> upToDelimiterP p)++oneSpaceP :: Parser Char+oneSpaceP = char ' '++anyStringP :: Parser Text+anyStringP = takeWhile1 (not . isSpace)++valueTP :: Parser Text+valueTP  =  ((<>) <$> string quoteT <*> ((<>) <$> takeWhile (/= quote) <*> string quoteT))+        <|> anyStringP+  where+    quote :: Char+    quote = '\"'++    quoteT :: Text+    quoteT = T.pack $ pure quote++commentaryP :: Parser ()+commentaryP = () <$ many' (many' oneSpaceP *> char '#' *> takeWhile (`notElem` ['\n', '\r']) *> endOfLine)++lineP :: Parser Text+lineP = commentaryP *> many' oneSpaceP *> valueTP <* tillEndOfLine <* commentaryP++tillEndOfLine :: Parser ()+tillEndOfLine = () <$ many' oneSpaceP <* endOfLine

@@ -0,0 +1,60 @@+module Bio.MAE.Type+  ( Mae (..)+  , Block (..)+  , Table (..)+  , MaeValue (..)+  , FromMaeValue (..)+  ) where++import           Data.Map.Strict (Map)+import           Data.Maybe      (fromJust)+import           Data.Text       (Text)++data Mae = Mae { version :: Text+               , blocks  :: [Block]+               }+  deriving (Eq, Show)++data Block = Block { blockName :: Text+                   , fields    :: Map Text MaeValue+                   , tables    :: [Table]+                   }+  deriving (Eq, Show)++data Table = Table { tableName :: Text+                   , contents  :: Map Text [MaeValue]+                   }+  deriving (Eq, Show)                   ++data MaeValue = IntMaeValue Int+              | RealMaeValue Float+              | StringMaeValue Text+              | BoolMaeValue Bool+              | Absent+  deriving (Eq, Show)++class FromMaeValue a where+    fromMaeValue :: MaeValue -> Maybe a++    unsafeFromMaeValue :: MaeValue -> a+    unsafeFromMaeValue = fromJust . fromMaeValue++instance FromMaeValue Int where+    fromMaeValue :: MaeValue -> Maybe Int+    fromMaeValue (IntMaeValue i) = Just i+    fromMaeValue _               = Nothing++instance FromMaeValue Float where+    fromMaeValue :: MaeValue -> Maybe Float+    fromMaeValue (RealMaeValue f) = Just f+    fromMaeValue _                = Nothing++instance FromMaeValue Bool where+    fromMaeValue :: MaeValue -> Maybe Bool+    fromMaeValue (BoolMaeValue b) = Just b+    fromMaeValue _                = Nothing++instance FromMaeValue Text where+    fromMaeValue :: MaeValue -> Maybe Text+    fromMaeValue (StringMaeValue t) = Just t+    fromMaeValue _                  = Nothing

@@ -5,23 +5,23 @@   , fetch   ) where +import           Bio.MMTF.Decode        (l2v) import           Bio.MMTF.MessagePack   ()-import           Bio.MMTF.Type   hiding ( IArray )-import           Bio.MMTF.Decode        ( l2a )+import           Bio.MMTF.Type import           Bio.Structure -import           Data.Array             ( Array, (!), elems )-import           Data.Int               ( Int32 )-import           Data.Bifunctor         ( Bifunctor (..) )-import           Data.List              ( mapAccumL, zip3, zip4 )-import           Data.Text              ( Text )-import           Data.ByteString.Lazy   ( ByteString )-import           Data.MessagePack       ( unpack )-import           Data.Monoid            ( (<>) )-import           Data.String            ( IsString (..) )-import           Control.Monad.IO.Class ( MonadIO )-import           Network.HTTP.Simple    ( httpLBS, getResponseBody )-import           Linear.V3              ( V3 (..) )+import           Control.Monad.IO.Class (MonadIO)+import           Data.Bifunctor         (Bifunctor (..))+import           Data.ByteString.Lazy   (ByteString)+import           Data.Int               (Int32)+import           Data.List              (mapAccumL, zip3, zip4)+import           Data.MessagePack       (unpack)+import           Data.Monoid            ((<>))+import           Data.String            (IsString (..))+import           Data.Text              (Text)+import           Data.Vector            (Vector, empty, toList, (!))+import           Linear.V3              (V3 (..))+import           Network.HTTP.Simple    (getResponseBody, httpLBS)  -- | Decodes a 'ByteString' to 'MMTF' --@@ -32,17 +32,17 @@ fetch :: MonadIO m => String -> m MMTF fetch pdbid = do let url = fromString $ "https://mmtf.rcsb.org/v1.0/full/" <> pdbid                  resp <- httpLBS url-                 decode (getResponseBody resp) +                 decode (getResponseBody resp)  instance StructureModels MMTF where-    modelsOf m = l2a (Model . l2a <$> zipWith (zipWith Chain) chainNames chainResis)+    modelsOf m = l2v (flip Model empty . l2v <$> zipWith (zipWith Chain) chainNames chainResis)       where-        chainsCnts = fromIntegral <$> elems (chainsPerModel (model m))-        groupsCnts = fromIntegral <$> elems (groupsPerChain (chain m))+        chainsCnts = fromIntegral <$> toList (chainsPerModel (model m))+        groupsCnts = fromIntegral <$> toList (groupsPerChain (chain m))         groupsRaws = snd $ mapAccumL getGroups (0, 0) groupsCnts         groups     = cutter chainsCnts groupsRaws-        chainNames = cutter chainsCnts (elems $ chainNameList $ chain m)-        chainResis = fmap (fmap (l2a . fmap mkResidue)) groups+        chainNames = cutter chainsCnts (toList $ chainNameList $ chain m)+        chainResis = fmap (fmap (l2v . fmap mkResidue)) groups          getGroups :: (Int, Int) -> Int -> ((Int, Int), [(GroupType, SecondaryStructure, [Atom])])         getGroups (chOffset, atOffset) sz = let chEnd        = chOffset + sz@@ -56,31 +56,38 @@                                             in  ((chEnd, atEnd), zip3 rgt rss ats)          getAtoms :: Int -> GroupType -> (Int, [Atom])-        getAtoms offset gt = let cl  = fmap fromIntegral . elems . gtFormalChargeList $ gt-                                 nl  = elems . gtAtomNameList $ gt-                                 el  = elems . gtElementList $ gt+        getAtoms offset gt = let cl  = fmap fromIntegral . toList . gtFormalChargeList $ gt+                                 nl  = toList . gtAtomNameList $ gt+                                 el  = toList . gtElementList $ gt                                  ics = [offset .. end - 1]                                  end = offset + length cl                              in  (end, mkAtom <$> zip4 cl nl el ics)          mkResidue :: (GroupType, SecondaryStructure, [Atom]) -> Residue-        mkResidue (gt, ss, atoms) = Residue (gtGroupName gt) (l2a atoms)+        mkResidue (gt, ss, atoms) = Residue (gtGroupName gt) (l2v atoms)                                             (mkBonds (gtBondAtomList gt) (gtBondOrderList gt))                                              ss (gtChemCompType gt) -        mkBonds :: Array Int (Int32, Int32) -> Array Int Int32 -> Array Int Bond-        mkBonds bal bol = let ball = bimap fromIntegral fromIntegral <$> elems bal-                              boll = fromIntegral <$> elems bol+        mkBonds :: Vector (Int32, Int32) -> Vector Int32 -> Vector (Bond LocalID)+        mkBonds bal bol = let ball = bimap (LocalID . fromIntegral) (LocalID . fromIntegral) <$> toList bal+                              boll = fromIntegral <$> toList bol                               res  = zipWith (\(f, t) o -> Bond f t o) ball boll-                          in  l2a res+                          in  l2v res          mkAtom :: (Int, Text, Text, Int) -> Atom-        mkAtom (fc, n, e, idx) = let x = xCoordList (atom m)+        mkAtom (fc, n, e, idx) = let i = atomIdList (atom m)+                                     x = xCoordList (atom m)                                      y = yCoordList (atom m)                                      z = zCoordList (atom m)                                      o = occupancyList (atom m)                                      b = bFactorList (atom m)-                                 in  Atom n e (V3 (x ! idx) (y ! idx) (z ! idx)) fc (b ! idx) (o ! idx)+                                 in  Atom (GlobalID $ fromIntegral (i ! idx))+                                           n+                                           e+                                           (V3 (x ! idx) (y ! idx) (z ! idx))+                                           fc+                                           (b ! idx)+                                           (o ! idx)          cutter :: [Int] -> [a] -> [[a]]         cutter []     []    = []

@@ -6,11 +6,11 @@  import           Control.Monad               ((>=>)) import           Data.ByteString.Lazy        (empty)+import           Data.Char                   (ord) import           Data.Map.Strict             (Map) import           Data.MessagePack            (Object) import           Data.Text                   (Text, pack)-import           Data.Char                   (ord)-import           Data.Array                  (listArray)+import           Data.Vector                 (Vector, fromList)  -- | Parses format data from ObjectMap --@@ -22,7 +22,7 @@ -- | Parses model data from ObjectMap -- modelData :: Monad m => Map Text Object -> m ModelData-modelData mp = ModelData . l2a <$> atP mp "chainsPerModel" asIntList+modelData mp = ModelData . l2v <$> atP mp "chainsPerModel" asIntList  -- | Parses chain data from ObjectMap --@@ -30,7 +30,7 @@ chainData mp = do gpc <- atP mp "groupsPerChain" asIntList                   cil <- codec5 . parseBinary <$> atP   mp "chainIdList"   asBinary                   cnl <- codec5 . parseBinary <$> atPMD mp "chainNameList" asBinary empty-                  pure $ ChainData (l2a gpc) (l2a cil) (l2a cnl)+                  pure $ ChainData (l2v gpc) (l2v cil) (l2v cnl)  -- | Parses atom data from ObjectMap --@@ -42,7 +42,7 @@                  ycl' <-      codec10 . parseBinary <$> atP   mp "yCoordList"    asBinary                  zcl' <-      codec10 . parseBinary <$> atP   mp "zCoordList"    asBinary                  ol' <-        codec9 . parseBinary <$> atPMD mp "occupancyList" asBinary empty-                 pure $ AtomData (l2a ail') (l2a all') (l2a bfl') (l2a xcl') (l2a ycl') (l2a zcl') (l2a ol')+                 pure $ AtomData (l2v ail') (l2v all') (l2v bfl') (l2v xcl') (l2v ycl') (l2v zcl') (l2v ol')  -- | Parses group data from ObjectMap --@@ -53,7 +53,7 @@                   ssl' <- fmap ssDec . codec2 . parseBinary <$> atPMD mp "secStructList"     asBinary empty                   icl' <-        c2s . codec6 . parseBinary <$> atPMD mp "insCodeList"       asBinary empty                   sil' <-              codec8 . parseBinary <$> atPMD mp "sequenceIndexList" asBinary empty-                  pure $ GroupData (l2a gl') (l2a gtl') (l2a gil') (l2a ssl') (l2a icl') (l2a sil')+                  pure $ GroupData (l2v gl') (l2v gtl') (l2v gil') (l2v ssl') (l2v icl') (l2v sil')  -- | Parses group type from ObjectMap --@@ -66,7 +66,7 @@                   gn'  <-          atP mp "groupName"        asStr                   slc' <-          atP mp "singleLetterCode" asChar                   cct' <-          atP mp "chemCompType"     asStr-                  pure $ GroupType (l2a fcl') (l2a anl') (l2a el') (l2a bal') (l2a bol') gn' slc' cct'+                  pure $ GroupType (l2v fcl') (l2v anl') (l2v el') (l2v bal') (l2v bol') gn' slc' cct'  -- | Parses structure data from ObjectMap --@@ -92,23 +92,23 @@                       btl' <-  l2pl . codec4 . parseBinary <$> atPMD mp "bondAtomList"        asBinary empty                       bol' <-         codec2 . parseBinary <$> atPMD mp "bondOrderList"       asBinary empty                       pure $ StructureData ttl' sid' dd' rd' nb' na'-                                          ng' nc' nm' sg' uc' (l2a nol')-                                           (l2a bal') (l2a el') res' rf'-                                           rw' (l2a em') (l2a btl') (l2a bol')+                                          ng' nc' nm' sg' uc' (l2v nol')+                                           (l2v bal') (l2v el') res' rf'+                                           rw' (l2v em') (l2v btl') (l2v bol')  -- | Parses bio assembly data from ObjectMap -- bioAssembly :: Monad m => Map Text Object -> m Assembly bioAssembly mp = do nme' <- atP mp "name"          asStr                     tlt' <- atP mp "transformList" asObjectList >>= traverse (transformObjectMap >=> transform)-                    pure $ Assembly (l2a tlt') nme'+                    pure $ Assembly (l2v tlt') nme'  -- | Parses transform data from ObjectMap -- transform :: Monad m => Map Text Object -> m Transform transform mp = do cil' <- atP mp "chainIndexList" asIntList                   mtx' <- atP mp "matrix"         asFloatList >>= m44Dec-                  pure $ Transform (l2a cil') mtx'+                  pure $ Transform (l2v cil') mtx'  -- | Parses entity data from ObjectMap --@@ -117,7 +117,7 @@                dsc' <- atP mp "description"    asStr                tpe' <- atP mp "type"           asStr                sqc' <- atP mp "sequence"       asStr-               pure $ Entity (l2a cil') dsc' tpe' sqc'+               pure $ Entity (l2v cil') dsc' tpe' sqc'  -- Helper functions @@ -130,8 +130,8 @@  -- | Converst list to an array ---l2a :: [a] -> IArray a-l2a lst = listArray (0, length lst - 1) lst+l2v :: [a] -> Vector a+l2v = fromList  -- | List to list of pairs --

@@ -1,16 +1,12 @@ module Bio.MMTF.Type where -import           Data.Int        ( Int32, Int8 )-import           Data.Text       ( Text )-import           Data.Array      ( Array )-import           GHC.Generics    ( Generic )-import           Control.DeepSeq ( NFData (..) )--import           Bio.Structure   ( SecondaryStructure )+import           Control.DeepSeq (NFData (..))+import           Data.Int        (Int32, Int8)+import           Data.Text       (Text)+import           Data.Vector     (Vector)+import           GHC.Generics    (Generic) --- | All arrays are int-indexed----type IArray a = Array Int a+import           Bio.Structure   (SecondaryStructure)  -- | Transformation matrix --@@ -33,21 +29,21 @@  -- | Transform data ---data Transform = Transform { chainIndexList :: !(IArray Int32) -- ^ indices into the 'chainIdList' and 'chainNameList' fields+data Transform = Transform { chainIndexList :: !(Vector Int32) -- ^ indices into the 'chainIdList' and 'chainNameList' fields                            , matrix         :: !M44            -- ^ 4x4 transformation matrix                            }   deriving (Show, Eq, Generic, NFData)  -- | Assembly data ---data Assembly = Assembly { transformList :: !(IArray Transform) -- ^ List of transform objects+data Assembly = Assembly { transformList :: !(Vector Transform) -- ^ List of transform objects                          , assemblyName  :: !Text               -- ^ Name of the biological assembly                          }   deriving (Show, Eq, Generic, NFData)  -- | Entity data ---data Entity = Entity { entityChainIndexList :: !(IArray Int32) -- ^ indices into the 'chainIdList' and 'chainNameList' fields+data Entity = Entity { entityChainIndexList :: !(Vector Int32) -- ^ indices into the 'chainIdList' and 'chainNameList' fields                      , entityDescription    :: !Text           -- ^ Description of the entity                      , entityType           :: !Text           -- ^ Name of the entity type                      , entitySequence       :: !Text           -- ^ Sequence of the full construct in one-letter-code@@ -56,11 +52,11 @@  -- | Group type data ---data GroupType = GroupType { gtFormalChargeList :: !(IArray Int32)          -- ^ List of formal charges-                           , gtAtomNameList     :: !(IArray Text)           -- ^ List of atom names-                           , gtElementList      :: !(IArray Text)           -- ^ List of elements-                           , gtBondAtomList     :: !(IArray (Int32, Int32)) -- ^ List of bonded atom indices-                           , gtBondOrderList    :: !(IArray Int32)          -- ^ List of bond orders+data GroupType = GroupType { gtFormalChargeList :: !(Vector Int32)          -- ^ List of formal charges+                           , gtAtomNameList     :: !(Vector Text)           -- ^ List of atom names+                           , gtElementList      :: !(Vector Text)           -- ^ List of elements+                           , gtBondAtomList     :: !(Vector (Int32, Int32)) -- ^ List of bonded atom indices+                           , gtBondOrderList    :: !(Vector Int32)          -- ^ List of bond orders                            , gtGroupName        :: !Text                    -- ^ The name of the group                            , gtSingleLetterCode :: !Char                    -- ^ The single letter code                            , gtChemCompType     :: !Text                    -- ^ The chemical component type@@ -87,52 +83,52 @@                                    , numModels           :: !Int32                   -- ^ The overall number of models in the structure                                    , spaceGroup          :: !Text                    -- ^ The Hermann-Mauguin space-group symbol                                    , unitCell            :: !(Maybe UnitCell)        -- ^ Array of six values defining the unit cell-                                   , ncsOperatorList     :: !(IArray M44)            -- ^ List of 4x4 transformation matrices (transformation matrices describe noncrystallographic symmetry operations needed to create all molecules in the unit cell)-                                   , bioAssemblyList     :: !(IArray Assembly)       -- ^ List of instructions on how to transform coordinates for an array of chains to create (biological) assemblies-                                   , entityList          :: !(IArray Entity)         -- ^ List of unique molecular entities within the structure+                                   , ncsOperatorList     :: !(Vector M44)            -- ^ List of 4x4 transformation matrices (transformation matrices describe noncrystallographic symmetry operations needed to create all molecules in the unit cell)+                                   , bioAssemblyList     :: !(Vector Assembly)       -- ^ List of instructions on how to transform coordinates for an array of chains to create (biological) assemblies+                                   , entityList          :: !(Vector Entity)         -- ^ List of unique molecular entities within the structure                                    , resolution          :: !(Maybe Float)           -- ^ The experimental resolution in Angstrom                                    , rFree               :: !(Maybe Float)           -- ^ The R-free value                                    , rWork               :: !(Maybe Float)           -- ^ The R-work value-                                   , experimentalMethods :: !(IArray Text)           -- ^ List of experimental methods employed for structure determination-                                   , bondAtomList        :: !(IArray (Int32, Int32)) -- ^ Pairs of values represent indices of covalently bonded atoms [binary (type 4)]-                                   , bondOrderList       :: !(IArray Int8)           -- ^ List of bond orders for bonds in 'bondAtomList' [binary (type 2)]+                                   , experimentalMethods :: !(Vector Text)           -- ^ List of experimental methods employed for structure determination+                                   , bondAtomList        :: !(Vector (Int32, Int32)) -- ^ Pairs of values represent indices of covalently bonded atoms [binary (type 4)]+                                   , bondOrderList       :: !(Vector Int8)           -- ^ List of bond orders for bonds in 'bondAtomList' [binary (type 2)]                                    }   deriving (Show, Eq, Generic, NFData)  -- | Models data ---data ModelData = ModelData { chainsPerModel :: !(IArray Int32) -- ^ List of the number of chains in each model+data ModelData = ModelData { chainsPerModel :: !(Vector Int32) -- ^ List of the number of chains in each model                            }   deriving (Show, Eq, Generic, NFData)  -- | Chains data ---data ChainData = ChainData { groupsPerChain :: !(IArray Int32)       -- ^ List of the number of groups (aka residues) in each chain-                           , chainIdList    :: !(IArray Text)        -- ^ List of chain IDs [binary (type 5)]-                           , chainNameList  :: !(IArray Text)        -- ^ List of chain names [binary (type 5)]+data ChainData = ChainData { groupsPerChain :: !(Vector Int32)       -- ^ List of the number of groups (aka residues) in each chain+                           , chainIdList    :: !(Vector Text)        -- ^ List of chain IDs [binary (type 5)]+                           , chainNameList  :: !(Vector Text)        -- ^ List of chain names [binary (type 5)]                            }   deriving (Show, Eq, Generic, NFData)  -- | Groups data ---data GroupData = GroupData { groupList         :: !(IArray GroupType)              -- ^ List of groupType objects-                           , groupTypeList     :: !(IArray Int32)                  -- ^ List of pointers to 'groupType' entries in 'groupList' by their keys [binary (type 4)]-                           , groupIdList       :: !(IArray Int32)                  -- ^ List of group (residue) numbers [binary (type 8)]-                           , secStructList     :: !(IArray SecondaryStructure)     -- ^ List of secondary structure assignments [binary (type 2)]-                           , insCodeList       :: !(IArray Text)                   -- ^ List of insertion codes, one for each group (residue) [binary (type 6)]-                           , sequenceIndexList :: !(IArray Int32)                  -- ^ List of indices that point into the sequence property of an entity object in the 'entityList' field that is associated with the chain the group belongs to [binary (type 8)]+data GroupData = GroupData { groupList         :: !(Vector GroupType)              -- ^ List of groupType objects+                           , groupTypeList     :: !(Vector Int32)                  -- ^ List of pointers to 'groupType' entries in 'groupList' by their keys [binary (type 4)]+                           , groupIdList       :: !(Vector Int32)                  -- ^ List of group (residue) numbers [binary (type 8)]+                           , secStructList     :: !(Vector SecondaryStructure)     -- ^ List of secondary structure assignments [binary (type 2)]+                           , insCodeList       :: !(Vector Text)                   -- ^ List of insertion codes, one for each group (residue) [binary (type 6)]+                           , sequenceIndexList :: !(Vector Int32)                  -- ^ List of indices that point into the sequence property of an entity object in the 'entityList' field that is associated with the chain the group belongs to [binary (type 8)]                            }   deriving (Show, Eq, Generic, NFData)  -- | Atoms data ---data AtomData = AtomData { atomIdList    :: !(IArray Int32)        -- ^ List of atom serial numbers [binary (type 8)]-                         , altLocList    :: !(IArray Text)         -- ^ List of alternate location labels, one for each atom [binary (type 6)]-                         , bFactorList   :: !(IArray Float)        -- ^ List of atom B-factors in in A^2, one for each atom [binary (type 10)]-                         , xCoordList    :: !(IArray Float)        -- ^ List of x atom coordinates in A, one for each atom [binary (type 10)]-                         , yCoordList    :: !(IArray Float)        -- ^ List of y atom coordinates in A, one for each atom [binary (type 10)]-                         , zCoordList    :: !(IArray Float)        -- ^ List of z atom coordinates in A, one for each atom [binary (type 10)]-                         , occupancyList :: !(IArray Float)        -- ^ List of atom occupancies, one for each atom [binary (type 9)]+data AtomData = AtomData { atomIdList    :: !(Vector Int32)        -- ^ List of atom serial numbers [binary (type 8)]+                         , altLocList    :: !(Vector Text)         -- ^ List of alternate location labels, one for each atom [binary (type 6)]+                         , bFactorList   :: !(Vector Float)        -- ^ List of atom B-factors in in A^2, one for each atom [binary (type 10)]+                         , xCoordList    :: !(Vector Float)        -- ^ List of x atom coordinates in A, one for each atom [binary (type 10)]+                         , yCoordList    :: !(Vector Float)        -- ^ List of y atom coordinates in A, one for each atom [binary (type 10)]+                         , zCoordList    :: !(Vector Float)        -- ^ List of z atom coordinates in A, one for each atom [binary (type 10)]+                         , occupancyList :: !(Vector Float)        -- ^ List of atom occupancies, one for each atom [binary (type 9)]                          }   deriving (Show, Eq, Generic, NFData) 

@@ -1,5 +1,61 @@+{-# OPTIONS_GHC -fno-warn-orphans #-} module Bio.PDB   (-   ) where +import qualified Bio.PDB.Type  as PDB+import           Bio.Structure++import           Control.Arrow ((&&&))+import           Data.Coerce   (coerce)+import           Data.Foldable (Foldable (..))+import           Data.Text     as T (Text, singleton, unpack)+import qualified Data.Vector   as V+import           Linear.V3     (V3 (..))++instance StructureModels PDB.PDB where+    modelsOf PDB.PDB {..} = fmap mkModel models+      where+        mkModel :: PDB.Model -> Model+        mkModel = flip Model V.empty . fmap mkChain++        mkChain :: PDB.Chain -> Chain+        mkChain = uncurry Chain . (mkChainName &&& mkChainResidues)++        mkChainName :: PDB.Chain -> Text+        mkChainName = T.singleton . PDB.atomChainID . safeFirstAtom++        mkChainResidues :: PDB.Chain -> V.Vector Residue+        mkChainResidues = V.fromList . fmap mkResidue . flip groupByResidue [] . pure . toList++        -- can be rewritten with sortOn and groupBy+        groupByResidue :: [[PDB.Atom]] -> [PDB.Atom] -> [[PDB.Atom]]+        groupByResidue res []       = res+        groupByResidue [] (x : xs)  = groupByResidue [[x]] xs+        groupByResidue res@(lastList : resultTail) (x : xs)+          | (PDB.atomResSeq x, PDB.atomICode x) == (PDB.atomResSeq (head lastList), PDB.atomICode (head lastList))+                                              = groupByResidue ((x : lastList) : resultTail) xs+          | otherwise                         = groupByResidue ([x] : res) xs++        safeFirstAtom :: V.Vector PDB.Atom -> PDB.Atom+        safeFirstAtom arr | V.length arr > 0 = arr V.! 0+                          | otherwise        = error "Could not pick first atom"+++        mkResidue :: [PDB.Atom] -> Residue+        mkResidue []    = error "Cound not make residue from empty list"+        mkResidue atoms = Residue (PDB.atomResName . head $ atoms)+                                  (V.fromList $ mkAtom <$> atoms)+                                  V.empty   -- now we do not read bonds+                                  Undefined -- now we do not read secondary structure+                                  ""        -- chemical component type?!+++        mkAtom :: PDB.Atom -> Atom+        mkAtom PDB.Atom{..} = Atom (coerce atomSerial)+                                   atomName+                                   atomElement+                                   (V3 atomX atomY atomZ)+                                   (read $ T.unpack atomCharge)+                                   atomTempFactor+                                   atomOccupancy

@@ -1,125 +1,88 @@-{-# LANGUAGE DuplicateRecordFields #-} module Bio.PDB.Type where -import           Data.Text                      ( Text )-import           Data.Array                     ( Array )--data Header = Header { classification :: Text-                     , depDate        :: Text-                     , idCode         :: Text-                     }--data Obsoleted = Obsoleted { repDate      :: Text-                           , idCode       :: Text-                           , rIdCode      :: Array Int Text-                           }--data Caveat = Caveat { idCode       :: Text-                     , comment      :: Text-                     }--data Compound = Compound { molId            :: Text-                         , molecule         :: Text-                         , chain            :: Array Int Text-                         , fragment         :: Text-                         , synonym          :: Array Int Text-                         , enzymeCommission :: Array Int Int-                         , engineered       :: Bool-                         , mutation         :: Bool-                         , otherDetails     :: Array Int Text-                         }--data Organism = Organism { scientific :: Text-                         , common     :: Text-                         , taxId      :: Text-                         }--data ExpressionSystem = ExpressionSystem { name             :: Text-                                         , common           :: Text-                                         , taxId            :: Text-                                         , strain           :: Text-                                         , variant          :: Text-                                         , cellLine         :: Text-                                         , atcc             :: Text-                                         , organ            :: Text-                                         , tissue           :: Text-                                         , cell             :: Text-                                         , organelle        :: Text-                                         , cellularLocation :: Text-                                         , vectorType       :: Text-                                         , vector           :: Text-                                         , plasmid          :: Text-                                         , gene             :: Text-                                         , otherDetails     :: Text-                                         }--data Source = Source { molId            :: Text-                     , synthetic        :: Text-                     , fragment         :: Text-                     , organism         :: Organism-                     , strain           :: Text-                     , variant          :: Text-                     , cellLine         :: Text-                     , atcc             :: Text-                     , tissue           :: Text-                     , cell             :: Text-                     , organelle        :: Text-                     , secretion        :: Text-                     , cellularLocation :: Text-                     , plasmid          :: Text-                     , gene             :: Text-                     , expressionSystem :: ExpressionSystem-                     , otherDetails     :: Text-                     }-----data Title = Title { header    :: Header-                   , obsoleted :: Obsoleted-                   , title     :: Text-                   , split     :: Array Int Text-                   , caveat    :: Caveat-                   , compound  :: Array Int Compound-                   -- TODO-                   }--data PrimaryStructure = PrimaryStructure -- TODO--data Heterogen = Heterogen -- TODO--data Helix = Helix {--                   }--data Sheet = Sheet {--                   }--data Secondary = Secondary { helixes :: Array Int Helix-                           , sheets  :: Array Int Sheet-                           }--data ConnectivityAnnotation = ConnectivityAnnotation -- TODO+import           Control.DeepSeq (NFData (..))+import           Data.Map.Strict (Map)+import           Data.Text       (Text)+import           Data.Vector     (Vector)+import           GHC.Generics    (Generic) -data Miscellaneous = Miscellaneous -- TODO+-- * Read PDB specification [here](http://www.wwpdb.org/documentation/file-format-content/format33/v3.3.html). -data Transformation = Transformation -- TODO+data PDB = PDB { title       :: Text+               , models      :: Vector Model+               , remarks     :: Map RemarkCode RemarkData+               , otherFields :: Map FieldType FieldData+               }+  deriving (Show, Eq, Generic, NFData) -data Coordinate = Coordinate {+type RemarkCode = Maybe Int+type RemarkData = Vector Text -                             }+type FieldData = Vector Text+data FieldType+   =+   -- Title Section (except TITLE and REMARKS)+     HEADER+   | OBSLTE+   | SPLT+   | CAVEAT+   | COMPND+   | SOURCE+   | KEYWDS+   | EXPDTA+   | NUMMDL+   | MDLTYP+   | AUTHOR+   | REVDAT+   | SPRSDE+   | JRNL+   -- Primary Structure Section+   | DBREF+   | DBREF1+   | DBREF2+   | SEQADV+   | SEQRES+   | MODRES+   -- Heterogen Section+   | HET+   | FORMUL+   | HETNAM+   | HETSYN+   -- Secondary Structure Section+   | HELIX+   | SHEET+   -- Connectivity Annotation Section+   | SSBOND+   | LINK+   | CISPEP+   -- Miscellaneous Features Section+   | SITE+   -- Crystallographic and Coordinate Transformation Section+   | CRYST1+   | MTRIXn+   | ORIGXn+   | SCALEn+   -- Bookkeeping Section+   | MASTER+  deriving (Show, Eq, Read, Generic, NFData) -data Connectivity = Connectivity -- TODO+type Model = Vector Chain -data Bookkeeping = Bookkeeping -- TODO+type Chain = Vector Atom -data PDB = PDB { title                  :: Title-               , primaryStructure       :: PrimaryStructure-               , heterogen              :: Heterogen-               , secondary              :: Secondary-               , connectivityAnnotation :: ConnectivityAnnotation-               , miscellaneous          :: Miscellaneous-               , transformation         :: Transformation-               , coordinate             :: Coordinate-               , connectivity           :: Connectivity-               , bookkeeping            :: Bookkeeping-               }+data Atom = Atom { atomSerial     :: Int     -- ^ Atom serial number.+                 , atomName       :: Text    -- ^ Atom name.+                 , atomAltLoc     :: Char    -- ^ Alternate location indicator.+                 , atomResName    :: Text    -- ^ Residue name.+                 , atomChainID    :: Char    -- ^ Chain identifier.+                 , atomResSeq     :: Int     -- ^ Residue sequence number.+                 , atomICode      :: Char    -- ^ Code for insertion of residues.+                 , atomX          :: Float   -- ^ Orthogonal coordinates for X in Angstroms.+                 , atomY          :: Float   -- ^ Orthogonal coordinates for Y in Angstroms.+                 , atomZ          :: Float   -- ^ Orthogonal coordinates for Z in Angstroms.+                 , atomOccupancy  :: Float   -- ^ Occupancy.+                 , atomTempFactor :: Float   -- ^ Temperature factor.+                 , atomElement    :: Text    -- ^ Element symbol, right-justified.+                 , atomCharge     :: Text    -- ^ Charge on the atom.+                 }+  deriving (Show, Eq, Generic, NFData)

@@ -1,17 +1,19 @@-{-# LANGUAGE DeriveGeneric  #-} {-# LANGUAGE DeriveAnyClass #-}+{-# LANGUAGE DeriveGeneric  #-} module Bio.Structure   ( SecondaryStructure (..)   , Atom (..), Bond (..)   , Residue (..), Chain (..), Model (..)   , StructureModels (..), StructureSerializable (..)+  , LocalID (..)+  , GlobalID (..)   ) where -import           Data.Array      ( Array )-import           Data.Text       ( Text )-import           GHC.Generics    ( Generic )-import           Control.DeepSeq ( NFData (..) )-import           Linear.V3       ( V3 )+import           Control.DeepSeq (NFData (..))+import           Data.Text       (Text)+import           Data.Vector     (Vector)+import           GHC.Generics    (Generic)+import           Linear.V3       (V3)  -- | Protein secondary structure --@@ -28,9 +30,16 @@  instance NFData SecondaryStructure +newtype GlobalID = GlobalID { getGlobalID :: Int }+  deriving (Eq, Show, Generic, NFData)++newtype LocalID  = LocalID { getLocalID :: Int }+  deriving (Eq, Show, Generic, NFData)+ -- | Generic atom representation ---data Atom = Atom { atomName     :: Text     -- ^ IUPAC atom name +data Atom = Atom { atomId       :: GlobalID -- ^ global identifier+                 , atomName     :: Text     -- ^ IUPAC atom name                  , atomElement  :: Text     -- ^ atom chemical element                  , atomCoords   :: V3 Float -- ^ 3D coordinates of atom                  , formalCharge :: Int      -- ^ Formal charge of atom@@ -43,42 +52,44 @@  -- | Generic chemical bond ---data Bond = Bond { bondStart :: Int  -- ^ index of first incident atom-                 , bondEnd   :: Int  -- ^ index of second incident atom-                 , bondOrder :: Int  -- ^ the order of chemical bond-                 }+data Bond m = Bond { bondStart :: m    -- ^ index of first incident atom+                   , bondEnd   :: m    -- ^ index of second incident atom+                   , bondOrder :: Int  -- ^ the order of chemical bond+                   }   deriving (Show, Eq, Generic) -instance NFData Bond+instance NFData a => NFData (Bond a)  -- | A set of atoms, organized to a residues ---data Residue = Residue { resName         :: Text               -- ^ residue name-                       , resAtoms        :: Array Int Atom     -- ^ a set of residue atoms-                       , resBonds        :: Array Int Bond     -- ^ a set of residue bonds-                       , resSecondary    :: SecondaryStructure -- ^ residue secondary structure-                       , resChemCompType :: Text               -- ^ chemical component type+data Residue = Residue { resName         :: Text                  -- ^ residue name+                       , resAtoms        :: Vector Atom           -- ^ a set of residue atoms+                       , resBonds        :: Vector (Bond LocalID) -- ^ a set of residue bonds with local identifiers (position in 'resAtoms')+                       , resSecondary    :: SecondaryStructure    -- ^ residue secondary structure+                       , resChemCompType :: Text                  -- ^ chemical component type                        }   deriving (Show, Eq, Generic, NFData)  -- | Chain organizes linear structure of residues -- data Chain = Chain { chainName     :: Text              -- ^ name of a chain-                   , chainResidues :: Array Int Residue -- ^ residues of a chain+                   , chainResidues :: Vector Residue    -- ^ residues of a chain                    }   deriving (Show, Eq, Generic, NFData)  -- | Model represents a single experiment of structure determination ---newtype Model = Model { modelChains :: Array Int Chain }+data Model = Model { modelChains :: Vector Chain           -- ^ chains in the model+                   , modelBonds  :: Vector (Bond GlobalID) -- ^ bonds with global identifiers (field `atomId` in 'Atom')+                   }   deriving (Show, Eq, Generic, NFData)  -- | Convert any format-specific data to an intermediate representation of structure class StructureModels a where     -- | Get an array of models-    modelsOf :: a -> Array Int Model+    modelsOf :: a -> Vector Model  -- | Serialize an intermediate representation of sequence to some specific format class StructureSerializable a where     -- | Serialize an array of models to some format-    serializeModels :: Array Int Model -> a+    serializeModels :: Vector Model -> a

@@ -2,10 +2,11 @@  module FASTASpec where -import           Bio.FASTA          (fromFile, toFile)-import           Bio.FASTA.Type     (FastaItem(..), Fasta)-import           Bio.Sequence       (bareSequence)-import           Prelude     hiding (writeFile, readFile)+import           Bio.FASTA        (fromFile, toFile)+import           Bio.FASTA.Type   (Fasta, FastaItem (..))+import           Bio.Sequence     (bareSequence)+import           Prelude          hiding (readFile, writeFile)+import           System.Directory (removeFile) import           Test.Hspec  correctFasta :: Fasta Char@@ -27,4 +28,5 @@     it "correctly write fasta into file" $ do         toFile correctFasta path         fasta <- fromFile path+        removeFile path         fasta `shouldBe` correctFasta

@@ -0,0 +1,136 @@+{-# LANGUAGE OverloadedStrings #-}++module MAEParserSpec where++import           Bio.MAE              (Block (..), MaeValue (..), Table (..),+                                       fromFile)+import           Bio.MAE.Parser       (blockP, tableP, versionP)+import           Data.Attoparsec.Text (parseOnly)+import qualified Data.Map.Strict      as M (fromList)+import           Data.Text            (Text)+import           Test.Hspec++maeParserSpec :: Spec+maeParserSpec = describe "Mae format parser." $ do+    versionPSpec+    tablePSpec+    blockPSpec+    maePSpec++versionPSpec :: Spec+versionPSpec = describe "version parser" $+    it "one and only version" $ parseOnly versionP version' `shouldBe` Right "2.0.0"+  where+    version' :: Text+    version' = "{\n  s_m_m2io_version\n ::: \n 2.0.0 \n } \n"++tablePSpec :: Spec+tablePSpec = describe "table parser" $ do+    it "simple table" $ parseOnly tableP simpleTableT `shouldBe` Right simpleTable+    it "missing values" $ parseOnly tableP tableWithMissingMaeValuesT `shouldBe` Right tableWithMissingMaeValues+    it "negative values" $ parseOnly tableP tableWithNegativeMaeValuesT `shouldBe` Right tableWithNegativeMaeValues+    it "quoted values" $ parseOnly tableP tableWithQuotedMaeValuesT `shouldBe` Right tableWithQuotedMaeValues+    it "with comments" $ parseOnly tableP tableWithCommentsT `shouldBe` Right tableWithComments++blockPSpec :: Spec+blockPSpec = describe "block parser" $ do+    it "simple block" $ parseOnly blockP simpleBlockT `shouldBe` Right simpleBlock+    it "with many tables" $ parseOnly blockP blockWithManyTablesT `shouldBe` Right blockWithManyTables++maePSpec :: Spec+maePSpec = describe "parses mae files up to the EOF" $ do+    it "Capri.mae" $ parseFileSpec "test/MAE/Capri.mae"+    it "h2o.mae" $ parseFileSpec "test/MAE/h2o.mae"+    it "docking_1.mae" $ parseFileSpec "test/MAE/docking_1.mae"+    it "docking_2.mae" $ parseFileSpec "test/MAE/docking_2.mae"++parseFileSpec :: FilePath -> Expectation+parseFileSpec path = fromFile path >> pure ()++simpleTableMap :: [(Text, [MaeValue])]+simpleTableMap = [ ("i_val", fmap IntMaeValue [1, 2, 3])+                 , ("r_val", fmap RealMaeValue [1.0, 2.28, 3.22])+                 , ("s_val", fmap StringMaeValue ["aaa", "bbb", "ccc"])+                 , ("b_val", fmap BoolMaeValue [False, True, False])+                 ]++simpleTable :: Table+simpleTable = Table "simple_table" $ M.fromList simpleTableMap++simpleTableT :: Text+simpleTableT = "  simple_table[3] {\n  i_val \n  r_val   \n  s_val\n b_val\n ::: \n 1 1 1.0 aaa 0  \n2 2 2.28 bbb 1\n  3 3 3.22   ccc 0 \n   ::: \n  } \n"++tableWithMissingMaeValuesMap :: [(Text, [MaeValue])]+tableWithMissingMaeValuesMap = [ ("i_can_be_missing", fmap IntMaeValue [1, 2, 3] <> [Absent, Absent])+                               , ("r_can_be_missing", fmap RealMaeValue [1.0, 2.28] <> [Absent, Absent, RealMaeValue 3.22])+                               , ("s_can_be_missing", [Absent, Absent] <> fmap StringMaeValue ["aaa", "bbb", "ccc"])+                               , ("r_can_be_missing_1", replicate 5 Absent)+                               , ("r_can_be_missing_2", [RealMaeValue 1.0, Absent, Absent] <> fmap RealMaeValue [2.28, 3.22])+                               , ("s_can_be_missing_1", fmap StringMaeValue ["aaa", "bbb", "ccc", "ddd", "eee"])+                               ]++tableWithMissingMaeValues :: Table+tableWithMissingMaeValues = Table "table_with_missing_values" $ M.fromList tableWithMissingMaeValuesMap++tableWithMissingMaeValuesT :: Text+tableWithMissingMaeValuesT = "table_with_missing_values[5]{  \n i_can_be_missing\n r_can_be_missing \n s_can_be_missing \n r_can_be_missing_1 \n r_can_be_missing_2 \n s_can_be_missing_1 \n :::\n 1 1 1.0 <> <> 1.0 aaa\n 2 2 2.28 <> <> <> bbb \n 3 3 <> aaa <> <> ccc \n 4 <> <> bbb <> 2.28 ddd \n 5 <> 3.22 ccc <> 3.22 eee \n ::: \n } \n"++tableWithNegativeMaeValuesMap :: [(Text, [MaeValue])]+tableWithNegativeMaeValuesMap = [ ("i_neg", fmap IntMaeValue [-1, -2, -3])+                                , ("r_neg", fmap RealMaeValue [-1.0, -2.28, -3.22])+                                ]++tableWithNegativeMaeValues :: Table+tableWithNegativeMaeValues = Table "table_with_negative_values" $ M.fromList tableWithNegativeMaeValuesMap++tableWithNegativeMaeValuesT :: Text+tableWithNegativeMaeValuesT = "table_with_negative_values[3]{  \n i_neg\n r_neg \n ::: \n 1 -1 -1.0 \n 2 -2 -2.28 \n 3 -3 -3.22\n ::: \n} \n"++tableWithQuotedMaeValuesMap :: [(Text, [MaeValue])]+tableWithQuotedMaeValuesMap = [ ("s_quote0", fmap StringMaeValue ["\"   ssss s \"", "\" more quotes \"", "\" this is long and dull comment \""])+                              , ("r_neg", fmap RealMaeValue [-1.0, -2.28, -3.22])+                              , ("s_quote", fmap StringMaeValue ["\" \"", "aaa", "\" this is long and dull comment \""])+                              , ("r_neg", fmap RealMaeValue [-1.0, -2.28, -3.22])+                              ]++tableWithQuotedMaeValues :: Table+tableWithQuotedMaeValues = Table "table_with_quoted_values" $ M.fromList tableWithQuotedMaeValuesMap++tableWithQuotedMaeValuesT :: Text+tableWithQuotedMaeValuesT = "table_with_quoted_values[3]{  \n s_quote0\n r_neg \n s_quote\n r_neg \n ::: \n 1 \"   ssss s \" -1.0 \" \" -1.0 \n 2 \" more quotes \" -2.28 aaa -2.28 \n 3 \" this is long and dull comment \" -3.22 \" this is long and dull comment \" -3.22\n ::: \n} \n"++tableWithCommentsMap :: [(Text, [MaeValue])]+tableWithCommentsMap = [ ("i_val", replicate 7 Absent)+                       , ("r_val", replicate 7 Absent)+                       ]++tableWithComments :: Table+tableWithComments = Table "table_with_comments" $ M.fromList tableWithCommentsMap++tableWithCommentsT :: Text+tableWithCommentsT = "  table_with_comments[7] {\n  # comments here? \n # this is useful comment # \n i_val \n # i can write \" any \" thing  in these comment \' s \n r_val \n # comments even here? \n ::: \n 1 <> <> \n 2 <> <> \n 3 <> <> \n 4 <> <> \n 5 <> <> \n 6 <> <> \n 7 <> <> \n ::: \n  } \n"++simpleBlockMap :: [(Text, MaeValue)]+simpleBlockMap = [ ("i_val", IntMaeValue 3)+                 , ("r_val", RealMaeValue 2.28)+                 , ("s_val", StringMaeValue "\"aaa\"")+                 ]++simpleBlock :: Block+simpleBlock = Block "simple_block" (M.fromList simpleBlockMap) [simpleTable]++simpleBlockT :: Text+simpleBlockT = "simple_block {\n i_val \n r_val \n s_val \n ::: \n 3 \n 2.28 \n \"aaa\"\n  " <> simpleTableT <> "}\n"++blockWithManyTablesMap :: [(Text, MaeValue)]+blockWithManyTablesMap = [ ("i_val", IntMaeValue 3)+                         , ("s_val", StringMaeValue "\" path/ to /my /favorite /dir\"")+                         , ("r_val", RealMaeValue (-2.28))+                         , ("s_val1", StringMaeValue "aaa")+                         ]++blockWithManyTables :: Block+blockWithManyTables = Block "block_with_many_tables" (M.fromList blockWithManyTablesMap) [simpleTable, tableWithComments, tableWithNegativeMaeValues]++blockWithManyTablesT :: Text+blockWithManyTablesT = "block_with_many_tables {\n i_val \n s_val \n r_val \n s_val1 \n ::: \n 3 \n \" path/ to /my /favorite /dir\" \n -2.28 \n aaa\n  " <> simpleTableT <> "\n" <> tableWithCommentsT <> "\n" <> tableWithNegativeMaeValuesT <> "}\n"

@@ -2,8 +2,8 @@  import           Bio.MMTF import           Bio.MMTF.Decode.Codec-import           Data.Array            ((!)) import           Data.Int              (Int8)+import           Data.Vector           ((!)) import           Test.Hspec  mmtfCodecSpec :: Spec

@@ -1,14 +1,15 @@ import           ABISpec+import           FastaParserSpec+import           FASTASpec+import           FastaWriterSpec import           GBParserSpec import           GBWriterSpec+import           MAEParserSpec import           MMTFSpec import           SequenceSpec import           System.IO import           Test.Hspec import           UniprotSpec-import           FastaParserSpec-import           FastaWriterSpec-import           FASTASpec  main :: IO () main = do@@ -35,3 +36,5 @@          fastaParserSpec          fastaSpec          fastaWriterSpec+         -- Mae+         maeParserSpec