dowsery - 100biere - software - libleipzig-python - SOURCE CODE

# Copyright (C) 2009, 2010 Robert Lehmann

from libleipzig.protocol import *
from libleipzig.transport import services
from suds import WebFault

__all__ = list(services.keys()) + ['WebFault']

from libleipzig.transport import services
from libleipzig import WebFault
import optparse

parser = optparse.OptionParser(
    epilog = "Services: %s" % ("; ".join(service._label for service
                                          in services.itervalues()))
        )
parser.add_option("-s", "--schema", action='store_true',
    help="show service's output schema and exit")
parser.add_option("-d", "--delimiter", metavar="DELIM", default=",",
    help="use DELIM instead of comma for field delimiter")
parser.add_option("-u", "--user",
    help="auth with USER (requires -p)")
parser.add_option("-p", "--password", metavar="PASS",
    help="auth with PASS (requires -u)")
parser.add_option("-v", "--verbose", action='store_true',
    help="enable SOAP debugging output on failure")

def main():
    import sys
    options, args = parser.parse_args()
    if not args:
        parser.print_help()
        return 1
    if args[0] not in services:
        print >>sys.stderr, "unknown service"
        return 1
    service, args = services[args[0]], args[1:]
    delim = options.delimiter.decode('string-escape')
    if options.schema:
        print delim.join(service._returns)
        return

    if options.user and options.password:
        #XXX fail if only one is given
        service.set_credentials(options.user, options.password)

    import logging
    if options.verbose:
        h = logging.StreamHandler(sys.stderr)
    else:
        class NullHandler(logging.Handler):
            def emit(self, record):
                pass
        h = NullHandler()
    logging.getLogger('suds.client').addHandler(h)

    try:
        results = service(*args)

... [truncated, 12 more lines] ...

# Copyright (C) 2009, 2010 Robert Lehmann
#
# SOAP description data
# cf. http://wortschatz.uni-leipzig.de/axis/servlet/ServiceOverviewServlet

from libleipzig.transport import service

@service('Grundform', 'Wortart')
def Baseform(Wort): """
    Return the lemmatized (base) form.
    """
@service('Wort', 'Kookkurrenz', 'Signifikanz')
def Cooccurrences(Wort, Mindestsignifikanz, Limit): """
    Return statistically significant co-occurrences.
    """
@service('Nummer', 'Satz')
def Sentences(Wort, Limit): """
    Return sample sentences containing the input word.
    """
@service('Wort', 'Nachbar', 'Signifikanz')
def RightNeighbours(Wort, Limit): """
    Return statistically significant right neighbours (words co-occurring
    immediately next to the input word).
    """
@service('Nachbar', 'Wort', 'Signifikanz')
def LeftNeighbours(Wort, Limit): """
    Returns statistically significant left neighbours (words co-occurring
    immediately next to the input word).
    """
@service('Anzahl', 'Frequenzklasse')
def Frequencies(Wort): """
    Return the frequency and frequency class.  Frequency classes are computed
    in relation to the most frequent word in the corpus.  The higher the class,
    the rarer the word.
    """
@service('Synonym', 'Wortart')
def Synonyms(Wort, Limit): """
    Return synonyms.  In other words, this is a thesaurus.
    """
@service('Synonym')
def Thesaurus(Wort, Limit): """
    Return synonyms (like the `Synonyms` service).  However, this lemmatizes
    the input word first and thus returns more synonyms.
    """
@service('Form')
def Wordforms(Word, Limit): """
    Return all other word forms of the same lemma.
    """
@service('Wort', 'Verwandter', 'Signifikanz')
def Similarity(Wort, Limit): """

... [truncated, 29 more lines] ...

# Copyright (C) 2009, 2010 Robert Lehmann

import functools
import inspect
import operator
import suds

BASEURL = 'http://pcai055.informatik.uni-leipzig.de:8100/axis/services/%s?wsdl'
services = {}

def service(*results):
    def wrapper(f):
        name = f.__name__
        args, _, _, _ = inspect.getargspec(f)

        # Exposing `client.options.cache.clear` is not sensible since suds
        # caches only for inter-session performance. Clearing it has no
        # runtime impact on the library as the *real* cache is the client
        # object keeping parsed WSDL definitions.

        auth = suds.transport.http.HttpAuthenticated(
               username='anonymous', password='anonymous')

        class Result(tuple): # poor man's namedtuple
            def __repr__(self):
                return "(%s)" % ", ".join(
                        "%s: %s" % d for d in zip(results, map(repr, self)))
        for n, typ in enumerate(results):
            setattr(Result, typ, property(operator.itemgetter(n)))
        Result.__name__ = "%sResult" % name

        def get_client(func, name, cred=None):
            if cred:
                return suds.client.Client(BASEURL % name,
                    transport=suds.transport.http.HttpAuthenticated(
                        username=cred[0], password=cred[1]))
            if not hasattr(func, '_client'):
                func._client = client = suds.client.Client(BASEURL % name,
                        transport=auth)
                client.options.cache.setduration(days=0)
            return func._client

        @functools.wraps(f)
        def func(*vectors, **options):
            # this prefetches the WSDL on library load!
            client = get_client(func, name, options.pop('auth', None))

            if len(args) != len(vectors):
                raise TypeError(
                    "service `%s' got %d arguments, expects %d (%s)" %

... [truncated, 40 more lines] ...