nltk 3.2__zip → 3.3__zip

{nltk-3.2 → nltk-3.3}/nltk/jsontags.py

@@ -1,63 +1,63 @@
-# -*- coding: utf-8 -*-
-# Natural Language Toolkit: JSON Encoder/Decoder Helpers
-#
-# Copyright (C) 2001-2015 NLTK Project
-# Author: Steven Xu <xxu@student.unimelb.edu.au>
-#
-# URL: <http://nltk.org/>
-# For license information, see LICENSE.TXT
-
-"""
-Register JSON tags, so the nltk data loader knows what module and class to look for.
-
-NLTK uses simple '!' tags to mark the types of objects, but the fully-qualified
-"tag:nltk.org,2011:" prefix is also accepted in case anyone ends up
-using it.
-"""
-
-import json
-
-json_tags = {}
-
-TAG_PREFIX = '!'
-
-def register_tag(cls):
-    """
-    Decorates a class to register it's json tag.
-    """
-    json_tags[TAG_PREFIX+getattr(cls, 'json_tag')] = cls
-    return cls
-
-class JSONTaggedEncoder(json.JSONEncoder):
-    def default(self, obj):
-        obj_tag = getattr(obj, 'json_tag', None)
-        if obj_tag is None:
-            return super(JSONTaggedEncoder, self).default(obj)
-        obj_tag = TAG_PREFIX + obj_tag
-        obj = obj.encode_json_obj()
-        return {obj_tag: obj}
-
-class JSONTaggedDecoder(json.JSONDecoder):
-    def decode(self, s):
-        return self.decode_obj(super(JSONTaggedDecoder, self).decode(s))
-
-    @classmethod
-    def decode_obj(cls, obj):
-        # Decode nested objects first.
-        if isinstance(obj, dict):
-            obj = dict((key, cls.decode_obj(val)) for (key, val) in obj.items())
-        elif isinstance(obj, list):
-            obj = list(cls.decode_obj(val) for val in obj)
-        # Check if we have a tagged object.
-        if not isinstance(obj, dict) or len(obj) != 1:
-            return obj
-        obj_tag = next(iter(obj.keys()))
-        if not obj_tag.startswith('!'):
-            return obj
-        if obj_tag not in json_tags:
-            raise ValueError('Unknown tag', obj_tag)
-        obj_cls = json_tags[obj_tag]
-        return obj_cls.decode_json_obj(obj[obj_tag])
-
-__all__ = ['register_tag', 'json_tags',
-           'JSONTaggedEncoder', 'JSONTaggedDecoder']
+# -*- coding: utf-8 -*-
+# Natural Language Toolkit: JSON Encoder/Decoder Helpers
+#
+# Copyright (C) 2001-2018 NLTK Project
+# Author: Steven Xu <xxu@student.unimelb.edu.au>
+#
+# URL: <http://nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Register JSON tags, so the nltk data loader knows what module and class to look for.
+
+NLTK uses simple '!' tags to mark the types of objects, but the fully-qualified
+"tag:nltk.org,2011:" prefix is also accepted in case anyone ends up
+using it.
+"""
+
+import json
+
+json_tags = {}
+
+TAG_PREFIX = '!'
+
+def register_tag(cls):
+    """
+    Decorates a class to register it's json tag.
+    """
+    json_tags[TAG_PREFIX+getattr(cls, 'json_tag')] = cls
+    return cls
+
+class JSONTaggedEncoder(json.JSONEncoder):
+    def default(self, obj):
+        obj_tag = getattr(obj, 'json_tag', None)
+        if obj_tag is None:
+            return super(JSONTaggedEncoder, self).default(obj)
+        obj_tag = TAG_PREFIX + obj_tag
+        obj = obj.encode_json_obj()
+        return {obj_tag: obj}
+
+class JSONTaggedDecoder(json.JSONDecoder):
+    def decode(self, s):
+        return self.decode_obj(super(JSONTaggedDecoder, self).decode(s))
+
+    @classmethod
+    def decode_obj(cls, obj):
+        # Decode nested objects first.
+        if isinstance(obj, dict):
+            obj = dict((key, cls.decode_obj(val)) for (key, val) in obj.items())
+        elif isinstance(obj, list):
+            obj = list(cls.decode_obj(val) for val in obj)
+        # Check if we have a tagged object.
+        if not isinstance(obj, dict) or len(obj) != 1:
+            return obj
+        obj_tag = next(iter(obj.keys()))
+        if not obj_tag.startswith('!'):
+            return obj
+        if obj_tag not in json_tags:
+            raise ValueError('Unknown tag', obj_tag)
+        obj_cls = json_tags[obj_tag]
+        return obj_cls.decode_json_obj(obj[obj_tag])
+
+__all__ = ['register_tag', 'json_tags',
+           'JSONTaggedEncoder', 'JSONTaggedDecoder']

{nltk-3.2 → nltk-3.3}/nltk/lazyimport.py

@@ -1,142 +1,142 @@
-# This module is from mx/DateTime/LazyModule.py and is
-# distributed under the terms of the eGenix.com Public License Agreement
-# http://www.egenix.com/products/eGenix.com-Public-License-1.1.0.pdf
-
-""" Helper to enable simple lazy module import.
-
-    'Lazy' means the actual import is deferred until an attribute is
-    requested from the module's namespace. This has the advantage of
-    allowing all imports to be done at the top of a script (in a
-    prominent and visible place) without having a great impact
-    on startup time.
-
-    Copyright (c) 1999-2005, Marc-Andre Lemburg; mailto:mal@lemburg.com
-    See the documentation for further information on copyrights,
-    or contact the author. All Rights Reserved.
-"""
-from __future__ import print_function
-
-### Constants
-
-_debug = 0
-
-###
-
-class LazyModule:
-
-    """ Lazy module class.
-
-        Lazy modules are imported into the given namespaces whenever a
-        non-special attribute (there are some attributes like __doc__
-        that class instances handle without calling __getattr__) is
-        requested. The module is then registered under the given name
-        in locals usually replacing the import wrapper instance. The
-        import itself is done using globals as global namespace.
-
-        Example of creating a lazy load module:
-
-        ISO = LazyModule('ISO',locals(),globals())
-
-        Later, requesting an attribute from ISO will load the module
-        automatically into the locals() namespace, overriding the
-        LazyModule instance:
-
-        t = ISO.Week(1998,1,1)
-
-    """
-    # Flag which inidicates whether the LazyModule is initialized or not
-    __lazymodule_init = 0
-
-    # Name of the module to load
-    __lazymodule_name = ''
-
-    # Flag which indicates whether the module was loaded or not
-    __lazymodule_loaded = 0
-
-    # Locals dictionary where to register the module
-    __lazymodule_locals = None
-
-    # Globals dictionary to use for the module import
-    __lazymodule_globals = None
-
-    def __init__(self, name, locals, globals=None):
-
-        """ Create a LazyModule instance wrapping module name.
-
-            The module will later on be registered in locals under the
-            given module name.
-
-            globals is optional and defaults to locals.
-
-        """
-        self.__lazymodule_locals = locals
-        if globals is None:
-            globals = locals
-        self.__lazymodule_globals = globals
-        mainname = globals.get('__name__', '')
-        if mainname:
-            self.__name__ = mainname + '.' + name
-            self.__lazymodule_name = name
-        else:
-            self.__name__ = self.__lazymodule_name = name
-        self.__lazymodule_init = 1
-
-    def __lazymodule_import(self):
-
-        """ Import the module now.
-        """
-        # Load and register module
-        name = self.__lazymodule_name
-        if self.__lazymodule_loaded:
-            return self.__lazymodule_locals[name]
-        if _debug:
-            print('LazyModule: Loading module %r' % name)
-        self.__lazymodule_locals[name] \
-             = module \
-             = __import__(name,
-                          self.__lazymodule_locals,
-                          self.__lazymodule_globals,
-                          '*')
-
-        # Fill namespace with all symbols from original module to
-        # provide faster access.
-        self.__dict__.update(module.__dict__)
-
-        # Set import flag
-        self.__dict__['__lazymodule_loaded'] = 1
-
-        if _debug:
-            print('LazyModule: Module %r loaded' % name)
-        return module
-
-    def __getattr__(self, name):
-
-        """ Import the module on demand and get the attribute.
-        """
-        if self.__lazymodule_loaded:
-            raise AttributeError(name)
-        if _debug:
-            print('LazyModule: ' \
-                  'Module load triggered by attribute %r read access' % name)
-        module = self.__lazymodule_import()
-        return getattr(module, name)
-
-    def __setattr__(self, name, value):
-
-        """ Import the module on demand and set the attribute.
-        """
-        if not self.__lazymodule_init:
-            self.__dict__[name] = value
-            return
-        if self.__lazymodule_loaded:
-            self.__lazymodule_locals[self.__lazymodule_name] = value
-            self.__dict__[name] = value
-            return
-        if _debug:
-            print('LazyModule: ' \
-                  'Module load triggered by attribute %r write access' % name)
-        module = self.__lazymodule_import()
-        setattr(module, name, value)
-
-    def __repr__(self):
-        return "<LazyModule '%s'>" % self.__name__
+# This module is from mx/DateTime/LazyModule.py and is
+# distributed under the terms of the eGenix.com Public License Agreement
+# http://www.egenix.com/products/eGenix.com-Public-License-1.1.0.pdf
+
+""" Helper to enable simple lazy module import.
+
+    'Lazy' means the actual import is deferred until an attribute is
+    requested from the module's namespace. This has the advantage of
+    allowing all imports to be done at the top of a script (in a
+    prominent and visible place) without having a great impact
+    on startup time.
+
+    Copyright (c) 1999-2005, Marc-Andre Lemburg; mailto:mal@lemburg.com
+    See the documentation for further information on copyrights,
+    or contact the author. All Rights Reserved.
+"""
+from __future__ import print_function
+
+### Constants
+
+_debug = 0
+
+###
+
+class LazyModule:
+
+    """ Lazy module class.
+
+        Lazy modules are imported into the given namespaces whenever a
+        non-special attribute (there are some attributes like __doc__
+        that class instances handle without calling __getattr__) is
+        requested. The module is then registered under the given name
+        in locals usually replacing the import wrapper instance. The
+        import itself is done using globals as global namespace.
+
+        Example of creating a lazy load module:
+
+        ISO = LazyModule('ISO',locals(),globals())
+
+        Later, requesting an attribute from ISO will load the module
+        automatically into the locals() namespace, overriding the
+        LazyModule instance:
+
+        t = ISO.Week(1998,1,1)
+
+    """
+    # Flag which inidicates whether the LazyModule is initialized or not
+    __lazymodule_init = 0
+
+    # Name of the module to load
+    __lazymodule_name = ''
+
+    # Flag which indicates whether the module was loaded or not
+    __lazymodule_loaded = 0
+
+    # Locals dictionary where to register the module
+    __lazymodule_locals = None
+
+    # Globals dictionary to use for the module import
+    __lazymodule_globals = None
+
+    def __init__(self, name, locals, globals=None):
+
+        """ Create a LazyModule instance wrapping module name.
+
+            The module will later on be registered in locals under the
+            given module name.
+
+            globals is optional and defaults to locals.
+
+        """
+        self.__lazymodule_locals = locals
+        if globals is None:
+            globals = locals
+        self.__lazymodule_globals = globals
+        mainname = globals.get('__name__', '')
+        if mainname:
+            self.__name__ = mainname + '.' + name
+            self.__lazymodule_name = name
+        else:
+            self.__name__ = self.__lazymodule_name = name
+        self.__lazymodule_init = 1
+
+    def __lazymodule_import(self):
+
+        """ Import the module now.
+        """
+        # Load and register module
+        name = self.__lazymodule_name
+        if self.__lazymodule_loaded:
+            return self.__lazymodule_locals[name]
+        if _debug:
+            print('LazyModule: Loading module %r' % name)
+        self.__lazymodule_locals[name] \
+             = module \
+             = __import__(name,
+                          self.__lazymodule_locals,
+                          self.__lazymodule_globals,
+                          '*')
+
+        # Fill namespace with all symbols from original module to
+        # provide faster access.
+        self.__dict__.update(module.__dict__)
+
+        # Set import flag
+        self.__dict__['__lazymodule_loaded'] = 1
+
+        if _debug:
+            print('LazyModule: Module %r loaded' % name)
+        return module
+
+    def __getattr__(self, name):
+
+        """ Import the module on demand and get the attribute.
+        """
+        if self.__lazymodule_loaded:
+            raise AttributeError(name)
+        if _debug:
+            print('LazyModule: ' \
+                  'Module load triggered by attribute %r read access' % name)
+        module = self.__lazymodule_import()
+        return getattr(module, name)
+
+    def __setattr__(self, name, value):
+
+        """ Import the module on demand and set the attribute.
+        """
+        if not self.__lazymodule_init:
+            self.__dict__[name] = value
+            return
+        if self.__lazymodule_loaded:
+            self.__lazymodule_locals[self.__lazymodule_name] = value
+            self.__dict__[name] = value
+            return
+        if _debug:
+            print('LazyModule: ' \
+                  'Module load triggered by attribute %r write access' % name)
+        module = self.__lazymodule_import()
+        setattr(module, name, value)
+
+    def __repr__(self):
+        return "<LazyModule '%s'>" % self.__name__

{nltk-3.2 → nltk-3.3}/nltk/metrics/__init__.py

@@ -1,29 +1,30 @@
-# Natural Language Toolkit: Metrics
-#
-# Copyright (C) 2001-2015 NLTK Project
-# Author: Steven Bird <stevenbird1@gmail.com>
-#         Edward Loper <edloper@gmail.com>
-# URL: <http://nltk.org/>
-# For license information, see LICENSE.TXT
-#
-
-"""
-NLTK Metrics
-
-Classes and methods for scoring processing modules.
-"""
-
-from nltk.metrics.scores import          (accuracy, precision, recall, f_measure,
-                                          log_likelihood, approxrand)
-from nltk.metrics.confusionmatrix import ConfusionMatrix
-from nltk.metrics.distance        import (edit_distance, binary_distance,
-                                          jaccard_distance, masi_distance,
-                                          interval_distance, custom_distance,
-                                          presence, fractional_presence)
-from nltk.metrics.paice           import Paice
-from nltk.metrics.segmentation    import windowdiff, ghd, pk
-from nltk.metrics.agreement       import AnnotationTask
-from nltk.metrics.association     import (NgramAssocMeasures, BigramAssocMeasures,
-                                          TrigramAssocMeasures, ContingencyMeasures)
-from nltk.metrics.spearman        import (spearman_correlation, ranks_from_sequence,
-                                          ranks_from_scores)
+# Natural Language Toolkit: Metrics
+#
+# Copyright (C) 2001-2018 NLTK Project
+# Author: Steven Bird <stevenbird1@gmail.com>
+#         Edward Loper <edloper@gmail.com>
+# URL: <http://nltk.org/>
+# For license information, see LICENSE.TXT
+#
+
+"""
+NLTK Metrics
+
+Classes and methods for scoring processing modules.
+"""
+
+from nltk.metrics.scores import          (accuracy, precision, recall, f_measure,
+                                          log_likelihood, approxrand)
+from nltk.metrics.confusionmatrix import ConfusionMatrix
+from nltk.metrics.distance        import (edit_distance, binary_distance,
+                                          jaccard_distance, masi_distance,
+                                          interval_distance, custom_distance,
+                                          presence, fractional_presence)
+from nltk.metrics.paice           import Paice
+from nltk.metrics.segmentation    import windowdiff, ghd, pk
+from nltk.metrics.agreement       import AnnotationTask
+from nltk.metrics.association     import (NgramAssocMeasures, BigramAssocMeasures,
+                                          TrigramAssocMeasures, ContingencyMeasures)
+from nltk.metrics.spearman        import (spearman_correlation, ranks_from_sequence,
+                                          ranks_from_scores)
+from nltk.metrics.aline           import align