opener-coreference-base 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 36e731f68489db9ea8890f201361498f0814e9de
-  data.tar.gz: 65d7f509e9d0f85eb735b9f7925a41f17be78eb0
+  metadata.gz: c35ea079c7c50da42f7bd17cddabf9cb79d1b93b
+  data.tar.gz: f836ce7b54e055bae722fda4890cd9a9a7cf8f39
 SHA512:
-  metadata.gz: e95ede174f6196081b58a779010e755ab84199636cdde86608218e972e6297be5e4de795b2fae43b8536cff70aa70783bf0c4e3f262428e28d164d43efeff9f7
-  data.tar.gz: 2fa4a2e030929ff3810eb82a0fa8674bc1433cb026aac02650a2c895c1e22f61430894858ff426b4b71db48ce8a4146bf3c118f9197d49aefbd9ebb0a7111a64
+  metadata.gz: e835457582de3c321d41649f19c9c7682351931d03cd8e526ae5aa3b217833b626a386727702b371743ee267d93dbbf1fbea97167d45223e312067412c200169
+  data.tar.gz: 67d0658e73efc718196354b34d6ecee09cb52ef2d32f2bea821b008fae8f066a43a3ce5ea967b56421de8e543b2a4867f82a55b69fe0995d5bcc8bf794f53ff4

data/core/vendor/dictconfig/__init__.py

@@ -0,0 +1 @@
+from dictconfig import *

data/core/vendor/dictconfig/dictconfig.py

@@ -0,0 +1,549 @@
+# Copyright 2009-2010 by Vinay Sajip. All Rights Reserved.
+#
+# Permission to use, copy, modify, and distribute this software and its
+# documentation for any purpose and without fee is hereby granted,
+# provided that the above copyright notice appear in all copies and that
+# both that copyright notice and this permission notice appear in
+# supporting documentation, and that the name of Vinay Sajip
+# not be used in advertising or publicity pertaining to distribution
+# of the software without specific, written prior permission.
+# VINAY SAJIP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+# ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
+# VINAY SAJIP BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+# ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
+# IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+import logging.handlers
+import re
+import sys
+import types
+
+IDENTIFIER = re.compile('^[a-z_][a-z0-9_]*$', re.I)
+
+def valid_ident(s):
+    m = IDENTIFIER.match(s)
+    if not m:
+        raise ValueError('Not a valid Python identifier: %r' % s)
+    return True
+
+#
+# This function is defined in logging only in recent versions of Python
+#
+try:
+    from logging import _checkLevel
+except ImportError:
+    def _checkLevel(level):
+        if isinstance(level, int):
+            rv = level
+        elif str(level) == level:
+            if level not in logging._levelNames:
+                raise ValueError('Unknown level: %r' % level)
+            rv = logging._levelNames[level]
+        else:
+            raise TypeError('Level not an integer or a '
+                            'valid string: %r' % level)
+        return rv
+
+# The ConvertingXXX classes are wrappers around standard Python containers,
+# and they serve to convert any suitable values in the container. The
+# conversion converts base dicts, lists and tuples to their wrapped
+# equivalents, whereas strings which match a conversion format are converted
+# appropriately.
+#
+# Each wrapper should have a configurator attribute holding the actual
+# configurator to use for conversion.
+
+class ConvertingDict(dict):
+    """A converting dictionary wrapper."""
+
+    def __getitem__(self, key):
+        value = dict.__getitem__(self, key)
+        result = self.configurator.convert(value)
+        #If the converted value is different, save for next time
+        if value is not result:
+            self[key] = result
+            if type(result) in (ConvertingDict, ConvertingList,
+                                ConvertingTuple):
+                result.parent = self
+                result.key = key
+        return result
+        
+    def get(self, key, default=None):
+        value = dict.get(self, key, default)
+        result = self.configurator.convert(value)
+        #If the converted value is different, save for next time
+        if value is not result:
+            self[key] = result
+            if type(result) in (ConvertingDict, ConvertingList,
+                                ConvertingTuple):
+                result.parent = self
+                result.key = key
+        return result
+        
+    def pop(self, key, default=None):
+        value = dict.pop(self, key, default)
+        result = self.configurator.convert(value)
+        if value is not result:
+            if type(result) in (ConvertingDict, ConvertingList,
+                                ConvertingTuple):
+                result.parent = self
+                result.key = key
+        return result
+
+class ConvertingList(list):
+    """A converting list wrapper."""
+    def __getitem__(self, key):
+        value = list.__getitem__(self, key)
+        result = self.configurator.convert(value)
+        #If the converted value is different, save for next time
+        if value is not result:
+            self[key] = result
+            if type(result) in (ConvertingDict, ConvertingList,
+                                ConvertingTuple):
+                result.parent = self
+                result.key = key
+        return result
+
+    def pop(self, idx=-1):
+        value = list.pop(self, idx)
+        result = self.configurator.convert(value)
+        if value is not result:
+            if type(result) in (ConvertingDict, ConvertingList,
+                                ConvertingTuple):
+                result.parent = self
+        return result
+
+class ConvertingTuple(tuple):
+    """A converting tuple wrapper."""
+    def __getitem__(self, key):
+        value = tuple.__getitem__(self, key)
+        result = self.configurator.convert(value)
+        if value is not result:
+            if type(result) in (ConvertingDict, ConvertingList,
+                                ConvertingTuple):
+                result.parent = self
+                result.key = key
+        return result
+
+class BaseConfigurator(object):
+    """
+    The configurator base class which defines some useful defaults.
+    """
+    
+    CONVERT_PATTERN = re.compile(r'^(?P<prefix>[a-z]+)://(?P<suffix>.*)$')
+
+    WORD_PATTERN = re.compile(r'^\s*(\w+)\s*')
+    DOT_PATTERN = re.compile(r'^\.\s*(\w+)\s*')
+    INDEX_PATTERN = re.compile(r'^\[\s*(\w+)\s*\]\s*')
+    DIGIT_PATTERN = re.compile(r'^\d+$')
+
+    value_converters = {
+        'ext' : 'ext_convert',
+        'cfg' : 'cfg_convert',
+    }
+
+    # We might want to use a different one, e.g. importlib
+    importer = __import__
+
+    def __init__(self, config):
+        self.config = ConvertingDict(config)
+        self.config.configurator = self
+
+    def resolve(self, s):
+        """
+        Resolve strings to objects using standard import and attribute
+        syntax.
+        """
+        name = s.split('.')
+        used = name.pop(0)
+        try:
+            found = self.importer(used)
+            for frag in name:
+                used += '.' + frag
+                try:
+                    found = getattr(found, frag)
+                except AttributeError:
+                    self.importer(used)
+                    found = getattr(found, frag)
+            return found
+        except ImportError:
+            e, tb = sys.exc_info()[1:]
+            v = ValueError('Cannot resolve %r: %s' % (s, e))
+            v.__cause__, v.__traceback__ = e, tb
+            raise v
+
+    def ext_convert(self, value):
+        """Default converter for the ext:// protocol."""
+        return self.resolve(value)
+    
+    def cfg_convert(self, value):
+        """Default converter for the cfg:// protocol."""
+        rest = value
+        m = self.WORD_PATTERN.match(rest)
+        if m is None:
+            raise ValueError("Unable to convert %r" % value)
+        else:
+            rest = rest[m.end():]
+            d = self.config[m.groups()[0]]
+            #print d, rest
+            while rest:
+                m = self.DOT_PATTERN.match(rest)
+                if m:
+                    d = d[m.groups()[0]]
+                else:
+                    m = self.INDEX_PATTERN.match(rest)
+                    if m:
+                        idx = m.groups()[0]
+                        if not self.DIGIT_PATTERN.match(idx):
+                            d = d[idx]
+                        else:
+                            try:
+                                n = int(idx) # try as number first (most likely)
+                                d = d[n]
+                            except TypeError:
+                                d = d[idx]
+                if m:
+                    rest = rest[m.end():]
+                else:
+                    raise ValueError('Unable to convert '
+                                     '%r at %r' % (value, rest))
+        #rest should be empty
+        return d
+
+    def convert(self, value):
+        """
+        Convert values to an appropriate type. dicts, lists and tuples are
+        replaced by their converting alternatives. Strings are checked to
+        see if they have a conversion format and are converted if they do.
+        """
+        if not isinstance(value, ConvertingDict) and isinstance(value, dict):
+            value = ConvertingDict(value)
+            value.configurator = self
+        elif not isinstance(value, ConvertingList) and isinstance(value, list):
+            value = ConvertingList(value)
+            value.configurator = self
+        elif not isinstance(value, ConvertingTuple) and\
+                 isinstance(value, tuple):
+            value = ConvertingTuple(value)
+            value.configurator = self
+        elif isinstance(value, basestring): # str for py3k
+            m = self.CONVERT_PATTERN.match(value)
+            if m:
+                d = m.groupdict()
+                prefix = d['prefix']
+                converter = self.value_converters.get(prefix, None)
+                if converter:
+                    suffix = d['suffix']
+                    converter = getattr(self, converter)
+                    value = converter(suffix)
+        return value
+    
+    def configure_custom(self, config):
+        """Configure an object with a user-supplied factory."""
+        c = config.pop('()')
+        if not hasattr(c, '__call__') and hasattr(types, 'ClassType') and type(c) != types.ClassType:
+            c = self.resolve(c)
+        props = config.pop('.', None)
+        # Check for valid identifiers
+        kwargs = dict([(k, config[k]) for k in config if valid_ident(k)])
+        result = c(**kwargs)
+        if props:
+            for name, value in props.items():
+                setattr(result, name, value)
+        return result
+
+    def as_tuple(self, value):
+        """Utility function which converts lists to tuples."""
+        if isinstance(value, list):
+            value = tuple(value)
+        return value
+
+class DictConfigurator(BaseConfigurator):
+    """
+    Configure logging using a dictionary-like object to describe the
+    configuration.
+    """
+
+    def configure(self):
+        """Do the configuration."""
+
+        config = self.config
+        if 'version' not in config:
+            raise ValueError("dictionary doesn't specify a version")
+        if config['version'] != 1:
+            raise ValueError("Unsupported version: %s" % config['version'])
+        incremental = config.pop('incremental', False)
+        EMPTY_DICT = {}
+        logging._acquireLock()
+        try:
+            if incremental:
+                handlers = config.get('handlers', EMPTY_DICT)
+                # incremental handler config only if handler name
+                # ties in to logging._handlers (Python 2.7)
+                if sys.version_info[:2] == (2, 7):
+                    for name in handlers:
+                        if name not in logging._handlers:
+                            raise ValueError('No handler found with '
+                                             'name %r'  % name)
+                        else:
+                            try:
+                                handler = logging._handlers[name]
+                                handler_config = handlers[name]
+                                level = handler_config.get('level', None)
+                                if level:
+                                    handler.setLevel(_checkLevel(level))
+                            except StandardError, e:
+                                raise ValueError('Unable to configure handler '
+                                                 '%r: %s' % (name, e))
+                loggers = config.get('loggers', EMPTY_DICT)
+                for name in loggers:
+                    try:
+                        self.configure_logger(name, loggers[name], True)
+                    except StandardError, e:
+                        raise ValueError('Unable to configure logger '
+                                         '%r: %s' % (name, e))
+                root = config.get('root', None)
+                if root:
+                    try:
+                        self.configure_root(root, True)
+                    except StandardError, e:
+                        raise ValueError('Unable to configure root '
+                                         'logger: %s' % e)
+            else:
+                disable_existing = config.pop('disable_existing_loggers', True)
+                
+                logging._handlers.clear()
+                del logging._handlerList[:]
+                    
+                # Do formatters first - they don't refer to anything else
+                formatters = config.get('formatters', EMPTY_DICT)
+                for name in formatters:
+                    try:
+                        formatters[name] = self.configure_formatter(
+                                                            formatters[name])
+                    except StandardError, e:
+                        raise ValueError('Unable to configure '
+                                         'formatter %r: %s' % (name, e))
+                # Next, do filters - they don't refer to anything else, either
+                filters = config.get('filters', EMPTY_DICT)
+                for name in filters:
+                    try:
+                        filters[name] = self.configure_filter(filters[name])
+                    except StandardError, e:
+                        raise ValueError('Unable to configure '
+                                         'filter %r: %s' % (name, e))
+
+                # Next, do handlers - they refer to formatters and filters
+                # As handlers can refer to other handlers, sort the keys
+                # to allow a deterministic order of configuration
+                handlers = config.get('handlers', EMPTY_DICT)
+                for name in sorted(handlers):
+                    try:
+                        handler = self.configure_handler(handlers[name])
+                        handler.name = name
+                        handlers[name] = handler
+                    except StandardError, e:
+                        raise ValueError('Unable to configure handler '
+                                         '%r: %s' % (name, e))
+                # Next, do loggers - they refer to handlers and filters
+                
+                #we don't want to lose the existing loggers,
+                #since other threads may have pointers to them.
+                #existing is set to contain all existing loggers,
+                #and as we go through the new configuration we
+                #remove any which are configured. At the end,
+                #what's left in existing is the set of loggers
+                #which were in the previous configuration but
+                #which are not in the new configuration.
+                root = logging.root
+                existing = root.manager.loggerDict.keys()
+                #The list needs to be sorted so that we can
+                #avoid disabling child loggers of explicitly
+                #named loggers. With a sorted list it is easier
+                #to find the child loggers.
+                existing.sort()
+                #We'll keep the list of existing loggers
+                #which are children of named loggers here...
+                child_loggers = []
+                #now set up the new ones...
+                loggers = config.get('loggers', EMPTY_DICT)
+                for name in loggers:
+                    if name in existing:
+                        i = existing.index(name)
+                        prefixed = name + "."
+                        pflen = len(prefixed)
+                        num_existing = len(existing)
+                        i = i + 1 # look at the entry after name
+                        while (i < num_existing) and\
+                              (existing[i][:pflen] == prefixed):
+                            child_loggers.append(existing[i])
+                            i = i + 1
+                        existing.remove(name)
+                    try:
+                        self.configure_logger(name, loggers[name])
+                    except StandardError, e:
+                        raise ValueError('Unable to configure logger '
+                                         '%r: %s' % (name, e))
+                    
+                #Disable any old loggers. There's no point deleting
+                #them as other threads may continue to hold references
+                #and by disabling them, you stop them doing any logging.
+                #However, don't disable children of named loggers, as that's
+                #probably not what was intended by the user.
+                for log in existing:
+                    logger = root.manager.loggerDict[log]
+                    if log in child_loggers:
+                        logger.level = logging.NOTSET
+                        logger.handlers = []
+                        logger.propagate = True
+                    elif disable_existing:
+                        logger.disabled = True
+    
+                # And finally, do the root logger
+                root = config.get('root', None)
+                if root:
+                    try:
+                        self.configure_root(root)                        
+                    except StandardError, e:
+                        raise ValueError('Unable to configure root '
+                                         'logger: %s' % e)
+        finally:
+            logging._releaseLock()
+
+    def configure_formatter(self, config):
+        """Configure a formatter from a dictionary."""
+        if '()' in config:
+            factory = config['()'] # for use in exception handler
+            try:
+                result = self.configure_custom(config)
+            except TypeError, te:
+                if "'format'" not in str(te):
+                    raise
+                #Name of parameter changed from fmt to format.
+                #Retry with old name.
+                #This is so that code can be used with older Python versions
+                #(e.g. by Django)
+                config['fmt'] = config.pop('format')
+                config['()'] = factory
+                result = self.configure_custom(config)
+        else:
+            fmt = config.get('format', None)
+            dfmt = config.get('datefmt', None)
+            result = logging.Formatter(fmt, dfmt)
+        return result
+    
+    def configure_filter(self, config):
+        """Configure a filter from a dictionary."""
+        if '()' in config:
+            result = self.configure_custom(config)
+        else:
+            name = config.get('name', '')
+            result = logging.Filter(name)
+        return result
+
+    def add_filters(self, filterer, filters):
+        """Add filters to a filterer from a list of names."""
+        for f in filters:
+            try:
+                filterer.addFilter(self.config['filters'][f])
+            except StandardError, e:
+                raise ValueError('Unable to add filter %r: %s' % (f, e))
+
+    def configure_handler(self, config):
+        """Configure a handler from a dictionary."""
+        formatter = config.pop('formatter', None)
+        if formatter:
+            try:
+                formatter = self.config['formatters'][formatter]
+            except StandardError, e:
+                raise ValueError('Unable to set formatter '
+                                 '%r: %s' % (formatter, e))
+        level = config.pop('level', None)
+        filters = config.pop('filters', None)
+        if '()' in config:
+            c = config.pop('()')
+            if not hasattr(c, '__call__') and hasattr(types, 'ClassType') and type(c) != types.ClassType:
+                c = self.resolve(c)
+            factory = c
+        else:
+            klass = self.resolve(config.pop('class'))
+            #Special case for handler which refers to another handler
+            if issubclass(klass, logging.handlers.MemoryHandler) and\
+                'target' in config:
+                try:
+                    config['target'] = self.config['handlers'][config['target']]
+                except StandardError, e:
+                    raise ValueError('Unable to set target handler '
+                                     '%r: %s' % (config['target'], e))
+            elif issubclass(klass, logging.handlers.SMTPHandler) and\
+                'mailhost' in config:
+                config['mailhost'] = self.as_tuple(config['mailhost'])
+            elif issubclass(klass, logging.handlers.SysLogHandler) and\
+                'address' in config:
+                config['address'] = self.as_tuple(config['address'])
+            factory = klass
+        kwargs = dict([(k, config[k]) for k in config if valid_ident(k)])
+        try:
+            result = factory(**kwargs)
+        except TypeError, te:
+            if "'stream'" not in str(te):
+                raise
+            #The argument name changed from strm to stream
+            #Retry with old name.
+            #This is so that code can be used with older Python versions
+            #(e.g. by Django)
+            kwargs['strm'] = kwargs.pop('stream')
+            result = factory(**kwargs)
+        if formatter:
+            result.setFormatter(formatter)
+        if level is not None:
+            result.setLevel(_checkLevel(level))
+        if filters:
+            self.add_filters(result, filters)
+        return result
+
+    def add_handlers(self, logger, handlers):
+        """Add handlers to a logger from a list of names."""
+        for h in handlers:
+            try:
+                logger.addHandler(self.config['handlers'][h])
+            except StandardError, e:
+                raise ValueError('Unable to add handler %r: %s' % (h, e))
+
+    def common_logger_config(self, logger, config, incremental=False):
+        """
+        Perform configuration which is common to root and non-root loggers.
+        """
+        level = config.get('level', None)
+        if level is not None:
+            logger.setLevel(_checkLevel(level))
+        if not incremental:
+            #Remove any existing handlers
+            for h in logger.handlers[:]:
+                logger.removeHandler(h)
+            handlers = config.get('handlers', None)
+            if handlers:
+                self.add_handlers(logger, handlers)
+            filters = config.get('filters', None)
+            if filters:
+                self.add_filters(logger, filters)
+        
+    def configure_logger(self, name, config, incremental=False):
+        """Configure a non-root logger from a dictionary."""
+        logger = logging.getLogger(name)
+        self.common_logger_config(logger, config, incremental)
+        propagate = config.get('propagate', None)
+        if propagate is not None:
+            logger.propagate = propagate
+            
+    def configure_root(self, config, incremental=False):
+        """Configure a root logger from a dictionary."""
+        root = logging.getLogger()
+        self.common_logger_config(root, config, incremental)
+
+dictConfigClass = DictConfigurator
+
+def dictConfig(config):
+    """Configure logging using a dictionary."""
+    dictConfigClass(config).configure()

data/core/vendor/pykaf/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright 2013 Josu Bermudez Galbarriatu <josu.bermudez@deusto.es>.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/core/vendor/pykaf/__init__.py

@@ -0,0 +1,427 @@
+# coding=utf-8
+""" Module for manage KAF formatted files. """
+
+from __future__ import unicode_literals
+
+__author__ = 'Josu Bermudez <josu.bermudez@deusto.es>'
+
+from lxml import etree
+
+# CONSTANT TEXT VALUES USED TO CONSTRUCT KAF
+KAF_TAG = "KAF"
+LANGUAGE_ATTRIBUTE = "{http://www.w3.org/XML/1998/namespace}lang"
+VERSION_ATTRIBUTE = "version"
+NS = {}
+
+KAF_HEADER_TAG = "kafHeader"
+NAME_ATTRIBUTE = "name"
+LINGUISTIC_PROCESSOR_HEAD = "linguisticProcessors"
+LAYER_ATTRIBUTE = "layer"
+LINGUISTIC_PROCESSOR_OCCURRENCE_TAG = "lp"
+TIMESTAMP_ATTRIBUTE = "timestamp"
+
+SPAN_TAG = "span"
+TARGET_ID_ATTRIBUTE = "id"
+TARGET_TAG = "target"
+
+TEXT_LAYER_TAG = "text"
+WORD_OCCURRENCE_TAG = "wf"
+WORD_ID_ATTRIBUTE = "wid"
+
+TERMS_LAYER_TAG = "terms"
+TERM_OCCURRENCE_TAG = "term"
+TERM_ID_ATTRIBUTE = "tid"
+NER_ATTRIBUTE = "ner"
+TYPE_ATTRIBUTE = "type"
+LEMMA_ATTRIBUTE = "lemma"
+POS_ATTRIBUTE = "pos"
+MORPHOFEAT_ATTRIBUTE = "morphofeat"
+
+NAMED_ENTITIES_LAYER_TAG = "entities"
+NAMED_ENTITY_OCCURRENCE_TAG = "entity"
+NAMED_ENTITY_ID_ATTRIBUTE = "eid"
+NAMED_ENTITY_TYPE_ATTRIBUTE = "type"
+NAMED_ENTITY_REFERENCES_GROUP_TAG = "references"
+
+CONSTITUENCY_LAYER = "constituency"
+CONSTITUENCY_TREE_TAG = "tree"
+CONSTITUENCY_NON_TERMINALS = "nt"
+CONSTITUENCY_TERMINALS = "t"
+CONSTITUENCY_EDGES = "edge"
+
+CHUNKS_LAYER_TAG = "chunks"
+CHUNK_OCCURRENCE_TAG = "chunk"
+CHUNK_CASE_ATTRIBUTE = "case"
+CHUNK_PHRASE_ATTRIBUTE = "phrase"
+CHUNK_HEAD_ATTRIBUTE = "head"
+CHUNK_ID_ATTRIBUTE = "cid"
+
+DEPENDENCY_LAYER_TAG = "deps"
+DEPENDENCY_OCCURRENCE_TAG = "dep"
+DEPENDENCY_FROM_ATTRIBUTE = "from"
+DEPENDENCY_FUNCTION_ATTRIBUTE = "rfunc"
+DEPENDENCY_TO_ATTRIBUTE = "to"
+
+EXTERNAL_REFERENCE_OCCURRENCE_TAG = "externalRef"
+EXTERNAL_REFERENCES_TAG = "externalReferences"
+
+COREFERENCE_LAYER_TAG = "coreferences"
+COREFERENCE_ID_ATTRIBUTE = "coid"
+COREFERENCE_OCCURRENCE_TAG = "coref"
+
+
+class KafDocument:
+    """ Manage a KAF document.
+    """
+    valid_word_attributes = ("sent", "para", "offset", "length", "page")
+    valid_external_attributes = ("resource", "reference", "reftype", "status", "source", "confidence")
+    valid_externalRef_attributes = ("resource", "reference")
+
+    def __init__(self, file_name=None, input_stream=None, language=None, version="2.0", header=None):
+        """ Prepare the document basic structure.
+        """
+        #parser = etree.XMLParser(remove_blank_text=True)
+
+        if file_name:
+            self.tree = etree.parse(file_name)#, parser=parser)
+            self.root = self.tree.getroot()
+        elif input_stream:
+            self.root = etree.fromstring(input_stream)#, parser=parser)
+            self.tree = etree.ElementTree(self.root)
+        else:
+            self.root = etree.Element(KAF_TAG, NS)
+            self.tree = etree.ElementTree(self.root)
+        if language:
+            self.root.attrib[LANGUAGE_ATTRIBUTE] = language
+
+        if version:
+            self.root.set(VERSION_ATTRIBUTE, version)
+
+        headers = self.tree.find(KAF_HEADER_TAG)
+        if headers is not None and len(headers):
+            self.kaf_header = headers
+        else:
+            self.kaf_header = None
+
+        if header:
+            self.set_header(header)
+
+        text_layer = self.tree.find(TEXT_LAYER_TAG)
+        if text_layer is not None and len(text_layer):
+            self.text = text_layer
+        else:
+            self.text = etree.SubElement(self.root, TEXT_LAYER_TAG)
+
+        terms_layer = self.tree.find(TERMS_LAYER_TAG)
+        if text_layer is not None and len(terms_layer):
+            self.terms = terms_layer
+        else:
+            self.terms = None
+
+        dependencies_layer = self.tree.find(DEPENDENCY_LAYER_TAG)
+        if dependencies_layer is not None and len(dependencies_layer):
+            self.dependencies = dependencies_layer
+        else:
+            self.dependencies = None
+
+        chunks_layer = self.tree.find(CHUNKS_LAYER_TAG)
+        if chunks_layer is not None and len(chunks_layer):
+            self.chunks = chunks_layer
+        else:
+            self.chunks = None
+
+        constituency_layer = self.tree.find(CONSTITUENCY_LAYER)
+        if constituency_layer is not None and len(constituency_layer):
+            self.constituency = constituency_layer
+        else:
+            self.constituency = None
+
+        named_entities_layer = self.tree.find(NAMED_ENTITIES_LAYER_TAG)
+        if named_entities_layer is not None and len(named_entities_layer):
+            self.entities = named_entities_layer
+        else:
+            self.entities = None
+
+        coreference_layer = self.tree.find(COREFERENCE_LAYER_TAG)
+        if coreference_layer is not None and len(coreference_layer):
+            self.coreferences = coreference_layer
+        else:
+            self.coreferences = None
+
+    def clear_header(self):
+        self.root.remove(self.kaf_header)
+        self.kaf_header = None
+
+    def set_header(self, kaf_header):
+        if self.kaf_header:
+            for element in kaf_header:
+                self.kaf_header.append(element)
+            self.kaf_header.attrib.update(kaf_header.attrib)
+        else:
+            self.kaf_header = kaf_header
+            self.root.append(self.kaf_header)
+
+    def add_linguistic_processors(self, layer, name, version, time_stamp):
+        if not self.kaf_header:
+            self.kaf_header = etree.SubElement(self.root, KAF_HEADER_TAG)
+
+        layer_find = self.kaf_header.find("./{0}..[@{1}='{2}']".format(LINGUISTIC_PROCESSOR_HEAD, LAYER_ATTRIBUTE, layer))
+        if layer_find:
+            layer = layer_find[0]
+        else:
+            layer = etree.SubElement(self.kaf_header, LINGUISTIC_PROCESSOR_HEAD, {LAYER_ATTRIBUTE: layer})
+
+        etree.SubElement(layer, LINGUISTIC_PROCESSOR_OCCURRENCE_TAG,
+                         {NAME_ATTRIBUTE: name, VERSION_ATTRIBUTE: version, TIMESTAMP_ATTRIBUTE: time_stamp})
+
+    def add_word(self, word, wid, **kwargs):
+        """Add a word to the KAF file.
+        A word have the next parameters/attributes;
+            + wid: the unique id for the word form.
+            + sent: sentence id of the token (optional)
+            + para: paragraph id (optional)
+            + offset: the offset of the word form (optional)
+            + length: the length of the original word form (optional)
+            + page: page id (optional)
+        """
+        # Prepare the word attributes
+        word_attributes = dict((k, v) for (k, v) in kwargs.iteritems() if k in self.valid_word_attributes)
+        word_attributes[WORD_ID_ATTRIBUTE] = wid
+        # Create a text subnode for the word and set its attributes
+        element = etree.SubElement(self.text, WORD_OCCURRENCE_TAG, word_attributes)
+        try:
+            element.text = word
+        except:
+            element.text = "XXXXXX"
+        return element
+
+    def get_words(self):
+        """ Return all the words in the document"""
+        return self.text[:]
+
+    def get_words_by_id(self, wid):
+        """ Return all the words in the document"""
+        results = self.text.find("{0}[@{1}='{2}']".format(WORD_OCCURRENCE_TAG, WORD_ID_ATTRIBUTE, wid))
+        return results and results[0]
+
+    def add_term(self, tid, pos=None, lemma=None, morphofeat=None, term_type=None, words=(), ner=None,
+                 external_refs=()):
+        """Add a term to the kaf file.
+        A Term have the next parameters/attributes:
+            tid: unique identifier
+            type: type of the term. Currently, 3 values are possible:
+                + open: open category term
+                + close: close category term
+            lemma: lemma of the term
+            pos: part of speech
+            morphofeat: PennTreebank part of speech tag
+            word: a list of id of the bounded words.
+            external_ref: A list of dictionaries that contains the external references.
+                Each reference have:
+                    + resource
+                    + reference
+                    + INCOMPLETE
+        """
+        if self.terms is None:
+            self.terms = etree.SubElement(self.root, TERMS_LAYER_TAG)
+
+        #TODO Complete external references
+
+        word_attributes = {TERM_ID_ATTRIBUTE: tid}
+        if pos:
+            word_attributes[POS_ATTRIBUTE] = pos
+        if lemma:
+            word_attributes[LEMMA_ATTRIBUTE] = lemma
+        if term_type:
+            word_attributes[TYPE_ATTRIBUTE] = term_type
+        if morphofeat:
+            word_attributes[MORPHOFEAT_ATTRIBUTE] = morphofeat
+        if ner:
+            word_attributes[NER_ATTRIBUTE] = ner
+        term = etree.SubElement(self.terms, TERM_OCCURRENCE_TAG, word_attributes)
+        if words:
+            span = etree.SubElement(term, SPAN_TAG)
+            for word in words:
+                etree.SubElement(span, TARGET_TAG, {TARGET_ID_ATTRIBUTE: word})
+        if external_refs:
+            span = etree.SubElement(term, EXTERNAL_REFERENCES_TAG)
+            for external_ref in external_refs:
+                ref_attributes = dict((k, v) for (k, v) in external_ref.iteritems()
+                                      if k in self.valid_externalRef_attributes)
+                keys = ref_attributes.keys()
+                for attribute in self.valid_externalRef_attributes:
+                    if not attribute in keys:
+                        raise Exception("External resource not have {0}".format(attribute))
+                etree.SubElement(span, EXTERNAL_REFERENCE_OCCURRENCE_TAG, ref_attributes)
+        return term
+
+    def get_terms(self):
+        """ Return all the words in the document"""
+        return self.root.findall("{0}/{1}".format(TERMS_LAYER_TAG, TERM_OCCURRENCE_TAG))
+
+    def get_terms_words(self, term):
+        return term.findall("{0}/{1}".format(SPAN_TAG, TARGET_TAG))
+
+    def get_terms_references(self, term):
+        return term.findall("{0}/{1}".format(EXTERNAL_REFERENCES_TAG, EXTERNAL_REFERENCE_OCCURRENCE_TAG))
+
+    def add_dependency(self, origen, to, rfunc):
+        """Add a new dependency relation in the text.
+        The dependency have the next parameters/attributes:
+            + from: term id of the source element
+            + to: term id of the target element
+            + rfunc: relational function. One of:
+                - mod: indicates the word introducing the dependent in a head- modifier relation.
+                - subj: indicates the subject in the grammatical relation Subject-Predicate.
+                - csubj, xsubj, ncsubj: The Grammatical Relations (RL)  csubj and xsubj may be used for clausal
+                    subjects, controlled from within, or without,  respectively. ncsubj is a non-clausal subject.
+                - dobj: Indicates the object in the grammatical relation between a predicate and its direct object.
+                - iobj: The relation between a predicate and a non-clausal complement introduced by a preposition;
+                    type indicates the preposition introducing the dependent.
+                - obj2: The relation between a predicate and the second non-clausal complement in ditransitive
+                    constructions.
+        """
+        if not self.dependencies:
+            self.dependencies = etree.SubElement(self.root, DEPENDENCY_LAYER_TAG)
+
+        dependency_attributes = {DEPENDENCY_FROM_ATTRIBUTE: origen,
+                                 DEPENDENCY_TO_ATTRIBUTE: to,
+                                 DEPENDENCY_FUNCTION_ATTRIBUTE: rfunc}
+        return etree.SubElement(self.dependencies, DEPENDENCY_OCCURRENCE_TAG, dependency_attributes)
+
+    def get_dependencies(self):
+        """Return all the words in the document"""
+        return self.root.findall("{0}/{1}".format(DEPENDENCY_LAYER_TAG, DEPENDENCY_OCCURRENCE_TAG))
+
+    def add_chunk(self, cid, head, phrase, case=None, terms=()):
+        """"Add a chunk to the kaf document.
+        Chunks are noun or prepositional phrases, spanning terms.A chunk have the following parameters/attributes:
+            + cid: unique identifier
+            + head: the chunk head's term id
+            + phrase: typo of the phrase.Valid values for the phrase elements are one of the following:
+                - NP: noun phrase
+                - VP: verbal phrase
+                - PP: prepositional phrase
+                - S: sentence
+                - O: other
+            + case (optional): declension case
+        """
+        # Secure the root
+        if not self.chunks:
+            self.chunks = etree.SubElement(self.root, CHUNKS_LAYER_TAG)
+            # Prepare the attributes
+        chunk_attributes = {CHUNK_ID_ATTRIBUTE: cid, CHUNK_HEAD_ATTRIBUTE: head, CHUNK_PHRASE_ATTRIBUTE: phrase}
+        if case:
+            chunk_attributes[CHUNK_CASE_ATTRIBUTE] = case
+            # Create , and attach, the chunk
+        chunk = etree.SubElement(self.chunks, CHUNK_OCCURRENCE_TAG, chunk_attributes)
+        # Add the span terms
+        if terms:
+            spans = etree.SubElement(chunk, SPAN_TAG)
+            for term in terms:
+                etree.SubElement(spans, TARGET_TAG, {TARGET_ID_ATTRIBUTE: term})
+        return chunk
+
+    def get_chunks(self):
+        """Return all the chunks of the text"""
+        return self.root.findall("{0}/{1}".format(DEPENDENCY_LAYER_TAG, DEPENDENCY_OCCURRENCE_TAG))
+
+    def get_chunk_terms(self, chunk):
+        """Return all the terms of a chunk."""
+        return chunk.findall("{0}/{1}".format(SPAN_TAG, TARGET_TAG))
+
+    def add_entity(self, eid, entity_type, references=()):
+        """ Add a entity in the document.
+        :param eid: The identification code of the entity.
+        :param references: The references (ids of the terms) contained in the entity.
+        :param entity_type: The type of the entity.
+        """
+
+        if self.entities is None:
+            self.entities = etree.SubElement(self.root, NAMED_ENTITIES_LAYER_TAG)
+
+        entity_attributes = {NAMED_ENTITY_ID_ATTRIBUTE: eid}
+        if entity_type:
+            entity_attributes[NAMED_ENTITY_TYPE_ATTRIBUTE] = entity_type
+        entity = etree.SubElement(self.entities, NAMED_ENTITY_OCCURRENCE_TAG, entity_attributes)
+        references_tag = etree.SubElement(entity, "references")
+        if references:
+            for reference in references:
+                span = etree.SubElement(references_tag, SPAN_TAG)
+                for token in reference:
+                    etree.SubElement(span, TARGET_TAG, {TARGET_ID_ATTRIBUTE: token})
+        return entity
+
+    def get_constituency_trees(self):
+        """Return all the constituency trees in the document"""
+        return self.root.findall("{0}/{1}".format(CONSTITUENCY_LAYER, CONSTITUENCY_TREE_TAG))
+
+    def get_contituent_tree_non_terminals(self, tree):
+        """Get al the non terminal constituents of the tree."""
+        return tree.findall(CONSTITUENCY_NON_TERMINALS)
+
+    def get_contituent_tree_terminals(self, tree):
+        """Get al the terminal constituents of the tree."""
+        return tree.findall(CONSTITUENCY_TERMINALS)
+
+    def get_contituent_tree_edges(self, tree):
+        """Get al the edges of the tree."""
+        return tree.findall(CONSTITUENCY_EDGES)
+
+    def get_contituent_terminal_words(self, chunk):
+        """Return all the terms of a terminal constituent."""
+        return chunk.findall("{0}/{1}".format(SPAN_TAG, TARGET_TAG))
+
+    def get_entities(self):
+        """Return all the Named Entities in the document"""
+        return self.root.findall("{0}/{1}".format(NAMED_ENTITIES_LAYER_TAG, NAMED_ENTITY_OCCURRENCE_TAG))
+
+    def get_entity_references(self, named_entity):
+        """Return all the terms of a  Named Entities in the document"""
+        return named_entity.findall("{0}/{1}".format(NAMED_ENTITY_REFERENCES_GROUP_TAG, SPAN_TAG))
+
+    def get_entity_reference_span(self, reference):
+        """Return all the terms of a  Named Entities in the document"""
+        return reference.findall(TARGET_TAG)
+
+    def add_coreference(self, coid, references=()):
+        """ Add a coreference cluster to the document.
+        :param coid: The identification code of the cluster.
+        :param references: The references contained in the cluster
+        """
+        if self.coreferences is None:
+            self.coreferences = etree.SubElement(self.root, COREFERENCE_LAYER_TAG)
+
+        coref_attrib = {COREFERENCE_ID_ATTRIBUTE: coid}
+        entity = etree.SubElement(self.coreferences, COREFERENCE_OCCURRENCE_TAG, coref_attrib)
+
+        if references:
+            for reference, form in references:
+                comment = etree.Comment(form.decode("utf-8").replace("-", " - "))
+                entity.append(comment)
+                span = etree.SubElement(entity, SPAN_TAG)
+                for token in reference:
+                    etree.SubElement(span, TARGET_TAG, {TARGET_ID_ATTRIBUTE: token})
+        return entity
+
+    def indent(self, elem, level=0):
+        i = "\n" + level * "  "
+        if len(elem):
+            if not elem.text or not elem.text.strip():
+                elem.text = i + "  "
+            if not elem.tail or not elem.tail.strip():
+                elem.tail = i
+            for child in elem:
+                self.indent(child, level+1)
+            # This seeks for the las child processed in for, is not a code identation error
+            if not child.tail or not child.tail.strip():
+                child.tail = i
+        else:
+            if level and (not elem.tail or not elem.tail.strip()):
+                elem.tail = i
+
+    def write(self, output, encoding):
+        """Write document into a file.
+        :param output: The output target for the document. May be a file type object or a file name."""
+        self.indent(self.root)
+        output.write(etree.tostring(self.root, encoding=encoding,))#, pretty_print=True, xml_declaration=True, with_comments=True))

data/lib/opener/coreferences/base/version.rb

@@ -1,7 +1,7 @@
 module Opener
   module Coreferences
     class Base
-      VERSION = '2.0.1'
+      VERSION = '2.0.2'
     end # Base
   end # Coreferences
 end # Opener

data/opener-coreference-base.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |gem|
   gem.files = Dir.glob([
     'core/corefgraph/**/*',
     'core/site-packages/pre_build/**/*',
-    'vendor/**/*',
+    'core/vendor/**/*',
     'ext/**/*',
     'lib/**/*',
     '*.gemspec',

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opener-coreference-base
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.2
 platform: ruby
 authors:
 - development@olery.com
@@ -276,6 +276,10 @@ files:
 - core/site-packages/pre_build/VUKafParserPy/KafDataObjectsMod.py
 - core/site-packages/pre_build/VUKafParserPy/KafParserMod.py
 - core/site-packages/pre_build/VUKafParserPy/__init__.py
+- core/vendor/dictconfig/__init__.py
+- core/vendor/dictconfig/dictconfig.py
+- core/vendor/pykaf/LICENSE.txt
+- core/vendor/pykaf/__init__.py
 - ext/hack/Rakefile
 - ext/hack/support.rb
 - lib/opener/coreferences/base.rb