FilesExpand file tree

 master

/

Sentence.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

142 lines (111 loc) · 3.56 KB

 master

/

Sentence.py

Copy path

Top

File metadata and controls

• Code
• Blame

142 lines (111 loc) · 3.56 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

# -*- coding: utf-8 -*-

# writer : lgy

# data : 2017-09-09

class Sentence(object):

""" Class Sentence """

def __init__(self):

self.text = None

self.text_type = None

self.fragment = None

self.words = list()

# Primary sentence type: 0: decl; 1: ynq; 2: whq; 3: impe; 4: excl

self.sentenceType = 0

self.isNegative = False

self.tense = None

self.role = -1 # Not determined yet

self.topics = []

# Text Analysis: Dictionary

self.inquiryParsingData = None

# Intent Analysis: Dictionary

self.intent_analysis = None

# Emotion Analysis: Dictionary

self.emotion_analysis = None

return

@staticmethod

def create_sentence(text, text_type):

sent = Sentence()

sent.text = text

sent.text_type = text_type

return sent

@staticmethod

def build_words(sentence):

if not sentence.inquiryParsingData:

return None

ta_wordlist = sentence.inquiryParsingData['wordlist']

ta_word_index = 0

words = []

while ta_word_index < len(ta_wordlist):

word = Word()

word.sentence = sentence

word.text = ta_wordlist[ta_word_index]

word.wordType = 0 # 'Normal'

if word.text in LingConstDef.FullWidthPunctuationList or word.text in LingConstDef.HalfWidthPunctuationList:

word.wordType = 1 # 'Punctuation'

words.append(word)

ta_word_index += 1

# if parsing is available, import rich information

if 'stanfordNlpAnalysis' in sentence.inquiryParsingData:

stanfordNlpAnalysisResult = sentence.inquiryParsingData['stanfordNlpAnalysis']

parsingItems = stanfordNlpAnalysisResult['parsingItems']

# Assumption: There is only one parsing item

# If the assumption is wrong, we need to check sentence seperator

parsingItem = parsingItems[0]

utterance = parsingItem.Utterance

ta_word_index = 0

parsing_item_index = 0

ta_offset = 0

parsing_offset = 0

parsing_uttr_word_index = 0

while ta_word_index < len(words) and parsing_uttr_word_index < len(utterance.words):

ta_word = words[ta_word_index]

parsing_uttr_word = utterance.words[parsing_uttr_word_index]

if ta_offset + len(words[ta_word_index].text) > parsing_offset + len(parsing_uttr_word.Text):

parsing_offset += len(parsing_uttr_word.Text)

parsing_uttr_word_index += 1

elif ta_offset + len(words[ta_word_index].text) < parsing_offset + len(parsing_uttr_word.Text):

ta_offset += len(words[ta_word_index].text)

ta_word_index += 1

else:

# Now achieve a matching point

if ta_offset == parsing_offset:

# Copy Part-of-Speech

ta_word.partOfSpeech = parsing_uttr_word.PartOfSpeech

if parsing_uttr_word.NamedEntityTag != "O":

ta_word.namedEntityTag = parsing_uttr_word.NamedEntityTag

ta_word.namedEntityOffset = ta_offset

ta_offset += len(words[ta_word_index].text)

parsing_offset += len(parsing_uttr_word.Text)

ta_word_index += 1

parsing_uttr_word_index += 1

return words

def getWordNumber(self):

return len(self.words)

def getFirstWord(self):

word = None

if len(self.words) > 0:

word = self.words[0]

return word

def getLastWord(self):

word = None

numOfWords = len(self.words)

if numOfWords > 0:

word = self.words[numOfWords - 1]

return word

def getSentenceType(self):

return self.sentenceType

def appendWord(self, word):

self.words.append(word)

return

def buildHierarchy(self):

# firstly, build link among words

numOfWords = len(self.words)

if numOfWords > 1:

i = 0;

while i < numOfWords - 1:

self.words[i].next = self.words[i + 1]

i += 1

i = numOfWords - 1;

while i > 0:

self.words[i].prev = self.words[i - 1]

i -= 1

return