{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}

module Text.CoreNLP.Types
  ( Dependency(..)
  , Entitymention(..)
  , Token(..)
  , Sentence(..)
  , PennPOS(..)
  , Coref(..)
  , CorefsId
  , Corefs
  , Document(..)
  , NamedEntity(..)
  ) where

import Control.Applicative
import qualified Data.Aeson as J
import Data.Aeson (FromJSON, ToJSON, (.:), (.:?))
import Data.Map (Map)
import Data.Maybe (fromMaybe)
import Data.Text (Text)
import GHC.Generics (Generic)


-- | Contains generic "hacks" we put on top to go around limitations like a
-- "type" keyword we can't use
jsonOpts :: J.Options
jsonOpts :: Options
jsonOpts = Options
J.defaultOptions {fieldLabelModifier :: String -> String
J.fieldLabelModifier = String -> String
fm}
  where
    fm :: String -> String
    fm :: String -> String
fm String
"type_" = String
"type"
    fm String
x = String
x


data Dependency = Dependency
  { Dependency -> Text
dep :: Text
  , Dependency -> Int
governor :: Int
  , Dependency -> Text
governorGloss :: Text
  , Dependency -> Int
dependent :: Int
  , Dependency -> Text
dependentGloss :: Text
  } deriving (Int -> Dependency -> String -> String
[Dependency] -> String -> String
Dependency -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Dependency] -> String -> String
$cshowList :: [Dependency] -> String -> String
show :: Dependency -> String
$cshow :: Dependency -> String
showsPrec :: Int -> Dependency -> String -> String
$cshowsPrec :: Int -> Dependency -> String -> String
Show, Dependency -> Dependency -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Dependency -> Dependency -> Bool
$c/= :: Dependency -> Dependency -> Bool
== :: Dependency -> Dependency -> Bool
$c== :: Dependency -> Dependency -> Bool
Eq, forall x. Rep Dependency x -> Dependency
forall x. Dependency -> Rep Dependency x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Dependency x -> Dependency
$cfrom :: forall x. Dependency -> Rep Dependency x
Generic)
instance FromJSON Dependency where
  parseJSON :: Value -> Parser Dependency
parseJSON = forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
J.genericParseJSON Options
jsonOpts
instance ToJSON Dependency where
  toJSON :: Dependency -> Value
toJSON = forall a.
(Generic a, GToJSON' Value Zero (Rep a)) =>
Options -> a -> Value
J.genericToJSON Options
jsonOpts


data Entitymention = Entitymention
  { Entitymention -> Int
docTokenBegin :: Int
  , Entitymention -> Int
docTokenEnd :: Int
  , Entitymention -> Int
tokenBegin :: Int
  , Entitymention -> Int
tokenEnd :: Int
  , Entitymention -> Text
text :: Text
  , Entitymention -> Int
characterOffsetBegin :: Int
  , Entitymention -> Int
characterOffsetEnd :: Int
  , Entitymention -> Text
ner :: Text
  , Entitymention -> Maybe Text
normalizedNER :: Maybe Text
  } deriving (Int -> Entitymention -> String -> String
[Entitymention] -> String -> String
Entitymention -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Entitymention] -> String -> String
$cshowList :: [Entitymention] -> String -> String
show :: Entitymention -> String
$cshow :: Entitymention -> String
showsPrec :: Int -> Entitymention -> String -> String
$cshowsPrec :: Int -> Entitymention -> String -> String
Show, Entitymention -> Entitymention -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Entitymention -> Entitymention -> Bool
$c/= :: Entitymention -> Entitymention -> Bool
== :: Entitymention -> Entitymention -> Bool
$c== :: Entitymention -> Entitymention -> Bool
Eq, forall x. Rep Entitymention x -> Entitymention
forall x. Entitymention -> Rep Entitymention x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Entitymention x -> Entitymention
$cfrom :: forall x. Entitymention -> Rep Entitymention x
Generic)
instance FromJSON Entitymention where
  parseJSON :: Value -> Parser Entitymention
parseJSON = forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
J.genericParseJSON Options
jsonOpts
instance ToJSON Entitymention where
  toJSON :: Entitymention -> Value
toJSON = forall a.
(Generic a, GToJSON' Value Zero (Rep a)) =>
Options -> a -> Value
J.genericToJSON Options
jsonOpts


data PennPOS
  = CC -- ^ Coordinating conjunction
  | CD -- ^ Cardinal number
  | DT -- ^ Determiner
  | EX -- ^ Existential *there*
  | FW -- ^ Foreign word
  | IN -- ^ Preposition or subordinating conjunction
  | JJ -- ^ Adjective
  | JJR -- ^ Adjective, comparative
  | JJS -- ^ Adjective, superlative
  | LS -- ^ List item marker
  | MD -- ^ Modal
  | NN -- ^ Noun, singular or mass
  | NNS -- ^ Noun, plural
  | NNP -- ^ Proper noun, singular
  | NNPS -- ^ Proper noun, plural
  | PDT -- ^ Predeterminer
  | POS -- ^ Possessive ending
  | PRP -- ^ Personal pronoun
  | PRPDollar -- ^ Possessive pronoun
  | RB -- ^ Adverb
  | RBR -- ^ Adverb, comparative
  | RBS -- ^ Adverb, superlative
  | RP -- ^ Particle
  | SYM -- ^ Symbol
  | TO -- ^ *to*
  | UH -- ^ Interjection
  | VB -- ^ Verb, base form
  | VBD -- ^ Verb, past tense
  | VBG -- ^ Verb, gerund or present participle
  | VBN -- ^ Verb, past participle
  | VBP -- ^ Verb, non-3rd person singular present
  | VBZ -- ^ Verb, 3rd person singular present
  | WDT -- ^ Wh-determiner
  | WP -- ^ Wh-pronoun
  | WPDollar -- ^ Possessive wh-pronoun
  | WRB -- ^ Wh-adverb
  | LRB -- ^ "-LRB-"? No idea what's this
  | RRB -- ^ "-RRB-"? No idea what's this
  | PosPunctuation -- ^ anyOf ".:,''$#$,", sometimes few together
  deriving (Int -> PennPOS -> String -> String
[PennPOS] -> String -> String
PennPOS -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [PennPOS] -> String -> String
$cshowList :: [PennPOS] -> String -> String
show :: PennPOS -> String
$cshow :: PennPOS -> String
showsPrec :: Int -> PennPOS -> String -> String
$cshowsPrec :: Int -> PennPOS -> String -> String
Show, PennPOS -> PennPOS -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PennPOS -> PennPOS -> Bool
$c/= :: PennPOS -> PennPOS -> Bool
== :: PennPOS -> PennPOS -> Bool
$c== :: PennPOS -> PennPOS -> Bool
Eq, forall x. Rep PennPOS x -> PennPOS
forall x. PennPOS -> Rep PennPOS x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PennPOS x -> PennPOS
$cfrom :: forall x. PennPOS -> Rep PennPOS x
Generic)
instance FromJSON PennPOS where
  parseJSON :: Value -> Parser PennPOS
parseJSON (J.String Text
"WP$") = forall (f :: * -> *) a. Applicative f => a -> f a
pure PennPOS
WPDollar
  parseJSON (J.String Text
"PRP$") = forall (f :: * -> *) a. Applicative f => a -> f a
pure PennPOS
PRPDollar
  parseJSON (J.String Text
"-LRB-") = forall (f :: * -> *) a. Applicative f => a -> f a
pure PennPOS
LRB
  parseJSON (J.String Text
"-RRB-") = forall (f :: * -> *) a. Applicative f => a -> f a
pure PennPOS
RRB
  parseJSON Value
x = forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
J.genericParseJSON Options
jsonOpts Value
x forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall {f :: * -> *}. MonadFail f => Value -> f PennPOS
parsePunctuation Value
x
    where
      parsePunctuation :: Value -> f PennPOS
parsePunctuation (J.String Text
_) = forall (f :: * -> *) a. Applicative f => a -> f a
pure PennPOS
PosPunctuation
      parsePunctuation Value
_ = forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Expecting POS to be a String"
instance ToJSON PennPOS where
  toJSON :: PennPOS -> Value
toJSON PennPOS
WPDollar = Text -> Value
J.String Text
"WP$"
  toJSON PennPOS
PRPDollar = Text -> Value
J.String Text
"PRP$"
  toJSON PennPOS
PosPunctuation = Text -> Value
J.String Text
"."
  toJSON PennPOS
LRB = Text -> Value
J.String Text
"-LRB-"
  toJSON PennPOS
RRB = Text -> Value
J.String Text
"-RRB-"
  toJSON PennPOS
x = forall a.
(Generic a, GToJSON' Value Zero (Rep a)) =>
Options -> a -> Value
J.genericToJSON Options
jsonOpts PennPOS
x


-- | See https:\/\/stanfordnlp.github.io\/CoreNLP\/ner.html
data NamedEntity
  = PERSON
  | LOCATION
  | ORGANIZATION
  | MISC
  | MONEY
  | NUMBER
  | ORDINAL
  | PERCENT
  | DATE
  | TIME
  | DURATION
  | SET
  | EMAIL
  | URL
  | CITY
  | STATE_OR_PROVINCE
  | COUNTRY
  | NATIONALITY
  | RELIGION
  | TITLE -- ^ Job title
  | IDEOLOGY
  | CRIMINAL_CHARGE
  | CAUSE_OF_DEATH
  | O -- ^ Not a named entity? TODO: check somehow
  deriving (Int -> NamedEntity -> String -> String
[NamedEntity] -> String -> String
NamedEntity -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [NamedEntity] -> String -> String
$cshowList :: [NamedEntity] -> String -> String
show :: NamedEntity -> String
$cshow :: NamedEntity -> String
showsPrec :: Int -> NamedEntity -> String -> String
$cshowsPrec :: Int -> NamedEntity -> String -> String
Show, NamedEntity -> NamedEntity -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NamedEntity -> NamedEntity -> Bool
$c/= :: NamedEntity -> NamedEntity -> Bool
== :: NamedEntity -> NamedEntity -> Bool
$c== :: NamedEntity -> NamedEntity -> Bool
Eq, forall x. Rep NamedEntity x -> NamedEntity
forall x. NamedEntity -> Rep NamedEntity x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NamedEntity x -> NamedEntity
$cfrom :: forall x. NamedEntity -> Rep NamedEntity x
Generic)
instance FromJSON NamedEntity where
  parseJSON :: Value -> Parser NamedEntity
parseJSON = forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
J.genericParseJSON Options
jsonOpts
instance ToJSON NamedEntity where
  toJSON :: NamedEntity -> Value
toJSON = forall a.
(Generic a, GToJSON' Value Zero (Rep a)) =>
Options -> a -> Value
J.genericToJSON Options
jsonOpts


data Token = Token
  { Token -> Int
index :: Int
  , Token -> Text
word :: Text
  , Token -> Text
originalText :: Text
  , Token -> Text
lemma :: Text
  , Token -> Int
characterOffsetBegin :: Int
  , Token -> Int
characterOffsetEnd :: Int
  , Token -> PennPOS
pos :: PennPOS
  , Token -> NamedEntity
ner :: NamedEntity
  , Token -> Maybe Text
speaker :: Maybe Text
  , Token -> Text
before :: Text
  , Token -> Text
after :: Text
  } deriving (Int -> Token -> String -> String
[Token] -> String -> String
Token -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Token] -> String -> String
$cshowList :: [Token] -> String -> String
show :: Token -> String
$cshow :: Token -> String
showsPrec :: Int -> Token -> String -> String
$cshowsPrec :: Int -> Token -> String -> String
Show, Token -> Token -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Token -> Token -> Bool
$c/= :: Token -> Token -> Bool
== :: Token -> Token -> Bool
$c== :: Token -> Token -> Bool
Eq, forall x. Rep Token x -> Token
forall x. Token -> Rep Token x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Token x -> Token
$cfrom :: forall x. Token -> Rep Token x
Generic)
instance FromJSON Token where
  parseJSON :: Value -> Parser Token
parseJSON = forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
J.genericParseJSON Options
jsonOpts
instance ToJSON Token where
  toJSON :: Token -> Value
toJSON = forall a.
(Generic a, GToJSON' Value Zero (Rep a)) =>
Options -> a -> Value
J.genericToJSON Options
jsonOpts


data Sentence = Sentence
  { Sentence -> Int
index :: Int
  , Sentence -> Maybe Text
parse :: Maybe Text
  , Sentence -> [Dependency]
basicDependencies :: [Dependency]
  , Sentence -> [Dependency]
enhancedDependencies :: [Dependency]
  , Sentence -> [Dependency]
enhancedPlusPlusDependencies :: [Dependency]
  , Sentence -> [Entitymention]
entitymentions :: [Entitymention]
  , Sentence -> [Token]
tokens :: [Token]
  } deriving (Int -> Sentence -> String -> String
[Sentence] -> String -> String
Sentence -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Sentence] -> String -> String
$cshowList :: [Sentence] -> String -> String
show :: Sentence -> String
$cshow :: Sentence -> String
showsPrec :: Int -> Sentence -> String -> String
$cshowsPrec :: Int -> Sentence -> String -> String
Show, Sentence -> Sentence -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sentence -> Sentence -> Bool
$c/= :: Sentence -> Sentence -> Bool
== :: Sentence -> Sentence -> Bool
$c== :: Sentence -> Sentence -> Bool
Eq, forall x. Rep Sentence x -> Sentence
forall x. Sentence -> Rep Sentence x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Sentence x -> Sentence
$cfrom :: forall x. Sentence -> Rep Sentence x
Generic)
instance FromJSON Sentence where
  parseJSON :: Value -> Parser Sentence
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
J.withObject String
"sentence" forall a b. (a -> b) -> a -> b
$ \Object
s -> do
    Int
index <- Object
s forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"index"
    Maybe Text
parse <- Object
s forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"parse"
    [Dependency]
basicDependencies <- forall a. a -> Maybe a -> a
fromMaybe [] forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
s forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"basicDependencies"
    [Dependency]
enhancedDependencies <- forall a. a -> Maybe a -> a
fromMaybe [] forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
s forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"enhancedDependencies"
    [Dependency]
enhancedPlusPlusDependencies <- forall a. a -> Maybe a -> a
fromMaybe [] forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
s forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"enhancedPlusPlusDependencies"
    [Entitymention]
entitymentions <- forall a. a -> Maybe a -> a
fromMaybe [] forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
s forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"entitymentions"
    [Token]
tokens <- forall a. a -> Maybe a -> a
fromMaybe [] forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
s forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"tokens"
    
    forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Sentence { Int
[Token]
[Entitymention]
[Dependency]
Maybe Text
tokens :: [Token]
entitymentions :: [Entitymention]
enhancedPlusPlusDependencies :: [Dependency]
enhancedDependencies :: [Dependency]
basicDependencies :: [Dependency]
parse :: Maybe Text
index :: Int
$sel:tokens:Sentence :: [Token]
$sel:entitymentions:Sentence :: [Entitymention]
$sel:enhancedPlusPlusDependencies:Sentence :: [Dependency]
$sel:enhancedDependencies:Sentence :: [Dependency]
$sel:basicDependencies:Sentence :: [Dependency]
$sel:parse:Sentence :: Maybe Text
$sel:index:Sentence :: Int
.. }
instance ToJSON Sentence where
  toJSON :: Sentence -> Value
toJSON = forall a.
(Generic a, GToJSON' Value Zero (Rep a)) =>
Options -> a -> Value
J.genericToJSON Options
jsonOpts


data Coref = Coref
  { Coref -> Int
id :: Int
  , Coref -> Text
text :: Text
  , Coref -> Text
type_ :: Text
  , Coref -> Text
number :: Text
  , Coref -> Text
gender :: Text
  , Coref -> Text
animacy :: Text
  , Coref -> Int
startIndex :: Int
  , Coref -> Int
endIndex :: Int
  , Coref -> Int
headIndex :: Int
  , Coref -> Int
sentNum :: Int
  , Coref -> [Int]
position :: [Int]
  , Coref -> Bool
isRepresentativeMention :: Bool
  } deriving (Int -> Coref -> String -> String
[Coref] -> String -> String
Coref -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Coref] -> String -> String
$cshowList :: [Coref] -> String -> String
show :: Coref -> String
$cshow :: Coref -> String
showsPrec :: Int -> Coref -> String -> String
$cshowsPrec :: Int -> Coref -> String -> String
Show, Coref -> Coref -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Coref -> Coref -> Bool
$c/= :: Coref -> Coref -> Bool
== :: Coref -> Coref -> Bool
$c== :: Coref -> Coref -> Bool
Eq, forall x. Rep Coref x -> Coref
forall x. Coref -> Rep Coref x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Coref x -> Coref
$cfrom :: forall x. Coref -> Rep Coref x
Generic)
instance FromJSON Coref where
  parseJSON :: Value -> Parser Coref
parseJSON = forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
J.genericParseJSON Options
jsonOpts
instance ToJSON Coref where
  toJSON :: Coref -> Value
toJSON = forall a.
(Generic a, GToJSON' Value Zero (Rep a)) =>
Options -> a -> Value
J.genericToJSON Options
jsonOpts


type CorefsId = Text


type Corefs = Map CorefsId [Coref]


data Document = Document
  { Document -> Maybe Text
docId :: Maybe Text
  , Document -> [Sentence]
sentences :: [Sentence]
  , Document -> Maybe Corefs
corefs :: Maybe Corefs
  } deriving (Int -> Document -> String -> String
[Document] -> String -> String
Document -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Document] -> String -> String
$cshowList :: [Document] -> String -> String
show :: Document -> String
$cshow :: Document -> String
showsPrec :: Int -> Document -> String -> String
$cshowsPrec :: Int -> Document -> String -> String
Show, Document -> Document -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Document -> Document -> Bool
$c/= :: Document -> Document -> Bool
== :: Document -> Document -> Bool
$c== :: Document -> Document -> Bool
Eq, forall x. Rep Document x -> Document
forall x. Document -> Rep Document x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Document x -> Document
$cfrom :: forall x. Document -> Rep Document x
Generic)
instance FromJSON Document where
  parseJSON :: Value -> Parser Document
parseJSON = forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
J.genericParseJSON Options
jsonOpts
instance ToJSON Document where
  toJSON :: Document -> Value
toJSON = forall a.
(Generic a, GToJSON' Value Zero (Rep a)) =>
Options -> a -> Value
J.genericToJSON Options
jsonOpts