Python ServerProxy.parse方法代码示例

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import parse [as 别名]
class Analyzer(object):
    """A proxy for the Analyzer. 
    Note: It assumes the server is running with the right grammar
    """
    def __init__(self, url):
        self.analyzer = ServerProxy(url, encoding='utf-8') 
        
    def parse(self, sentence):        
        total = self.analyzer.parse(sentence)
        parse = total['parse']
        spans = total['spans']

        return [as_featurestruct(r, s) for r, s in parse]

    def full_parse(self, sentence):
        total = self.analyzer.parse(sentence)
        parse = [as_featurestruct(r, s) for r, s in total['parse']]
        spans = total['spans']
        return {'spans': spans, 'parse': parse, 'original': total['parse'], 'costs':total['costs']}
    
    def issubtype(self, typesystem, child, parent):
        return self.analyzer.issubtype(typesystem, child, parent)

    def get_mapping_path(self):
        return os.path.realpath(self.analyzer.get_mapping())

    def get_mappings(self):
        return self.analyzer.get_mappings()

    def get_lexicon(self):
        return self.analyzer.get_lexicon()

    def get_utterances(self):
        return self.analyzer.get_utterances()

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import parse [as 别名]
class Analyzer(object):
    """A proxy for the Analyzer. 
    Note: It assumes the server is running with the right grammar
    """
    def __init__(self, url):
        self.analyzer = ServerProxy(url) 
        
    def parse(self, sentence):        
        return [as_featurestruct(r, s) for r, s in self.analyzer.parse(sentence)]
    
    def issubtype(self, typesystem, child, parent):
        return self.analyzer.issubtype(typesystem, child, parent)

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import parse [as 别名]
class Analyzer(object):
    """A proxy for the Analyzer. 
    Note: It assumes the server is running with the right grammar
    """
    def __init__(self, url):
        self.analyzer = ServerProxy(url, encoding='utf-8') 
        
    def parse(self, sentence):        
        return [as_featurestruct(r, s) for r, s in self.analyzer.parse(sentence)]
    
    def issubtype(self, typesystem, child, parent):
        return self.analyzer.issubtype(typesystem, child, parent)

    def get_mapping_path(self):
        return os.path.realpath(self.analyzer.get_mapping())

    def get_mappings(self):
        return self.analyzer.get_mappings()

    def get_lexicon(self):
        return self.analyzer.get_lexicon()

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import parse [as 别名]
def test_remote(sentence='Robot1, move to location 1 2!'):
    analyzer = ServerProxy('http://localhost:8090')
    return [as_featurestruct(r, s) for r, s in analyzer.parse(sentence)]

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import parse [as 别名]
def test_remote(sentence ='Robot1, move to location 1 2!'):
    from feature import as_featurestruct
    a = ServerProxy('http://localhost:8090')
    d = a.parse(sentence)
    s = as_featurestruct(d[0])
    return s

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import parse [as 别名]
class AlignServer(object):
    # the maximum number that the parser for Alpino XML will be reused
    max_alpino_parser_reuse = 1000

    # regexp to detect unescaped ampercent, that is, not part of an entity such &, ', etc.
    regexp = re.compile(r"&(?!(?:[a-zA-Z][a-zA-Z0-9]*|#\d+);)")

    def __init__(self, tokenizer=None, alpino=None, graph_aligner=None):
        self.init_tokenizer(tokenizer)
        self.init_alpino(alpino)
        self.init_graph_xml_parser()
        self.init_graph_aligner(graph_aligner)
        self.init_others()

        # a pair of graphbank dummies, which are needed when creating a new
        # GraphMapping instance
        self._graphbanks = Pair(GraphBank("", "alpino"), GraphBank("", "alpino"))

    def init_tokenizer(self, tokenizer=None):
        self._tokenizer = tokenizer

    def init_alpino(self, alpino):
        # "if alpino: ..." does not work because op peculiarities of xml-rpc
        # implementation
        if alpino is None:
            host = "http://%s:%d" % (ALPINO_HOST, ALPINO_PORT)
            self._alpino = ServerProxy(host, encoding="iso-8859-1")
        else:
            self._alpino = alpino

        self._alpino.parse("test")

    def init_graph_xml_parser(self):
        self._alpino_xml_parser = AlpinoParser()
        self._alpino_parser_reused = 0
        # feed fake root node to the xml parser
        self._alpino_xml_parser.parse_string('<?xml version="1.0" encoding="utf-8"?>\n<treebank>')

    def init_graph_aligner(self, graph_aligner):
        if graph_aligner:
            self._graph_aligner = graph_aligner
        else:
            self._graph_aligner = GraphAligner()

        self.no_rel = self._graph_aligner.descriptor.no_rel

    def init_others(self):
        # hook for subclasses
        pass

    def align(self, source_sent, target_sent):
        # the strings received here after transport through XML-RPC are either
        # plain ascii or unicode
        sent_pair = Pair(source_sent, target_sent)

        tok_sent_pair = self._tokenize(sent_pair)

        parse_pair = self._parse(tok_sent_pair)

        graph_pair = self._load_graphs(parse_pair)

        instances = self._align_graphs(graph_pair)

        parse_align, phrase_align = self._get_alignment(instances, graph_pair)

        return dict(
            source_sent=sent_pair.source,
            target_sent=sent_pair.target,
            source_tok=tok_sent_pair.source,
            target_tok=tok_sent_pair.target,
            source_parse=parse_pair.source,
            target_parse=parse_pair.target,
            parse_align=parse_align,
            phrase_align=phrase_align,
        )

    def _tokenize(self, sent_pair):
        if self._tokenizer:
            return self._tokenizer(sent_pair)
        else:
            return sent_pair

    def _parse(self, tok_sent_pair):
        return Pair(self._parse_single_sent(tok_sent_pair.source), self._parse_single_sent(tok_sent_pair.target))

    def _parse_single_sent(self, tok_sent):
        # Sentence will be of type unicode if the original sentence passed
        # to the server proxy (client) contained any non-ascii chars, but
        # will be of type str otherwise. Input to the alpino server proxy
        # must be iso-8859-1 encoded, so we have to convert
        tok_sent = tok_sent.encode("iso-8859-1")

        graph = self._alpino.parse(tok_sent)

        # The returned parse is string of type unicode or str, regardless
        # of what the xml header produced by alpino says. First we get rid
        # of this xml header.
        return graph.split("\n", 1)[1]

    def _load_graphs(self, parse_pair):
#.........这里部分代码省略.........

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import parse [as 别名]
    metavar="utf8|latin1|ascii|...",
    help="character encoding of output (default is utf8)")

parser.add_argument(
    '-t', '--timeout', 
    type=int,
    default=30,
    help="timeout in seconds (default is 30)")
    

args = parser.parse_args()

server_proxy = ServerProxy("http://" + args.host, encoding="iso-8859-1")

try:
    server_proxy.parse("test")
except socket.error, inst:
    sys.stderr.write('No Alpino server running on host "%s" ?\n' % args.host)
    raise inst
    

while True:
    try:
        sentence = raw_input()
    except (KeyboardInterrupt, EOFError):
        exit(0)

    # convert to utf-8
    sentence = sentence.decode(args.input_encoding).encode("utf-8")
    
    try: