Python Lexicon.compile方法代码示例

# 需要导入模块: from lexicon import Lexicon [as 别名]
# 或者: from lexicon.Lexicon import compile [as 别名]

#.........这里部分代码省略.........
			self.reset()
		pickle.dump(self.__tuple(), f, -1)
		f.flush()
		f.close()

	def load(self, filename):
		"""
		Load the lect from the file system.
		The format is a Python I{pickle} file compressed using the GZip algorithm.

		@param filename: The name of the file to load.
		@type filename: str
		"""
		f = utilities.ZipFile(filename, "rb")
		tuple = pickle.load(f)
		self.code, self.name, self.english_name, self.properties, self.__p_o_s, self.__lemma_categories, self.__categories, self.grammar, self.lexicon, self.inflections = tuple
		f.close()

	def append_p_o_s(self, name, lemma_categories = (), categories = ()):
		"""
		Append a part of speech, defined by its name and the categories of lemmas and words belonging to it.

		@param name: The name of the part of speech.
		@type name: str
		@param lemma_categories: The categories of lemmas belonging to the part of speech. Optional.
		@type lemma_categories: tuple of str
		@param categories: The categories of words belonging to the part of speech. Optional.
		@type categories: tuple of str
		"""
		if name in self.__p_o_s:
			raise KeyError("P.o.s. %s already exists" % name)
		self.__p_o_s += (name,)
		self.__lemma_categories[name] = tuple(lemma_categories)
		self.__categories[name] = tuple(categories)

	def get_p_o_s_names(self):
		"""
		Return the names of the parts of speech.

		@rtype: tuple of str
		"""
		return self.__p_o_s

	def get_categories(self, name):
		"""
		Return the lemma and word categories of a part of speech.

		@param name: The name of the part of speech.
		@type name: str

		@rtype: tuple of tuple of str
		@return: A tuple where the first element is a tuple containing the lemma categories and the second contains the word categories.
		"""
		if name not in self.__p_o_s:
			raise KeyError(name)
		return (self.__lemma_categories[name], self.__categories[name])

	def read(self, expression):
		"""
		Interprete an expression.

		@param expression: The expression to read.
		@type expression: C{str}

		@raise fsa.ParseError: If the grammar can not parse the expression.
		@raise expression.ExpressionParseError: If no syntax tree could be constructed.
		@raise tokenizer.UnknownTokenException: If an unexpected token is encountered.

		@return: The list of possible interpretations.
		@rtype: list of ParseTree
		"""

		if not isinstance(expression, unicode):
			raise TypeError("%s is not Unicode" % repr(expression))

		tokenizer = self.lexicon.compile(self.properties, False)
                # @type tokenizer pylilac.core.tokenizer.Tokenizer
		parser = self.grammar.compile(False)
                # @type parser pylilac.core.fsa.Parser
		er = ExpressionReader(tokenizer, parser)
		return er(expression)

	def compile(self, force = False):
		"""
		Compile the lexicon and the grammar.
		@param force: Recompile even if the result of a previous compilation was in memory.
		@type force: bool
		@raise grammar.GrammarError: If anomalies are encountered while precompiling the grammar.
		@raise tokenizer.UnknownTokenException: If an unknown character is encountered while precompiling the lexicon.
		@raise fsa.ParseError: If unexpected tokens or stops are encountered.
		"""
		self.lexicon.compile(self.properties, force)
		self.grammar.compile(force)

	def reset(self):
		"""
		Delete the internal results of the last compiling.
		"""
		self.lexicon.reset()
		self.grammar.reset()