Merge branch 'release-1.0.3'

MDANSE/Core/ClassRegistry.py

@@ -30,29 +30,15 @@ Created on Mar 30, 2015
 :author: Eric C. Pellegrini
 '''
 
-import abc
 import glob
 import imp
 import inspect
 import os
 import sys
 
-class _Meta(type):
-    '''
-    Metaclass that allows to use the :py:meth:`__getitem__` method at a class level for the class that has been built.
-     
-    The class that uses this metaclass must define a class attribute named _registry that will be used
-    by the :py:meth:`__getitem__` method.
-    '''
-         
-    def __getitem__(self, item):
-        """
-        Returns a given item stored in the class registry
-        """
-         
-        return self._registry[item]
+from MDANSE.Core.Singleton import Singleton
     
-class ClassRegistry(abc.ABCMeta):
+class ClassRegistry(object):
     '''
     Metaclass that registers the classes that make the MDANSE framework.
 
@@ -67,49 +53,41 @@ class ClassRegistry(abc.ABCMeta):
     class attribute will not be registered.    
     '''
     
-    __metaclass__ = _Meta
+    __metaclass__ = Singleton
 
-    __interfaces = set()
+    def __init__(self):
         
-    _registry = {}
+        self._registry = {}
         
-    def __init__(self, name, bases, namespace):
-        '''
-        Constructor
-        
-        :param name: the name of the class to be built by this metaclass
-        :type name: str
-        :param bases: the base classes of the class to be built by this metaclass
-        :type bases: tuple 
-        :param namespace: the attributes and methods of the class to be built by this metaclass
-        :type namespace: dict
-        '''
+        self._sections = {}
         
-        super(ClassRegistry, self).__init__(name, bases, namespace)
+    def __setitem__(self,name,cls):
 
-        # If the class objet does not have a type attribute, it will not be registered.    
-        typ = getattr(self, 'type', None)
-        if typ is None:
+        # The class to be registered must have a class attribute "_registry" to be registered, otherwise return       
+        clsRegistry = getattr(cls,"_registry")
+        if clsRegistry is None:
             return
         
-        # If the class object is metaclassed by ClassRegistry then a new section of the registry will
-        # be created with its type attribute.
-        metaClass = namespace.get("__metaclass__", None)                              
-        if metaClass is ClassRegistry:
-            ClassRegistry.__interfaces.add(self)
-            if (ClassRegistry._registry.has_key(typ)):
+        # And this attribute must be a string for the class to be registerable otherwise return
+        if not isinstance(clsRegistry,basestring):
             return
-            ClassRegistry._registry[typ] = {}
         
-        else:
+        # Fetch the branch of the registry corresponding the one of the class to be registred, otherwise create a new branch        
+        d = self._registry.setdefault(clsRegistry,{})
         
-            for interface in ClassRegistry.__interfaces:
-                if issubclass(self, interface):
-                    ClassRegistry._registry[interface.type][typ] = self
-                    break
+        # If a class has already been registered with that name return
+        if d.has_key(name):
+            return
 
-    @classmethod      
-    def update_registry(cls,packageDir):
+        setattr(cls,"_type",name)
+        
+        d[name] = cls
+                
+    def __getitem__(self,name):
+        
+        return self._registry.get(name,{})
+
+    def update(self,packageDir):
         '''
         Update the classes registry by importing all the modules contained in a given package.
         
@@ -142,9 +120,7 @@ class ClassRegistry(abc.ABCMeta):
                 if os.path.abspath(os.path.dirname(mod.__file__)) != os.path.abspath(moduleDir):                    
                     print "A module with name %s is already present in your distribution with %s path." % (moduleName,moduleDir)
     
-    
-    @classmethod
-    def info(cls, interface):
+    def info(self, interface):
         '''
         Returns informations about the subclasses of a given base class stored in the registry.
         
@@ -155,7 +131,7 @@ class ClassRegistry(abc.ABCMeta):
         :rtype: str
         '''
                 
-        if not cls._registry.has_key(interface):
+        if not self._registry.has_key(interface):
             return "The interface " + interface + " is not registered"
 
         words = ["Name", "Class","File"]
@@ -168,7 +144,7 @@ class ClassRegistry(abc.ABCMeta):
         maxlength = -1
         
         # Loop over the registry items.
-        for i, (k, v) in enumerate(sorted(cls._registry[interface].items())):
+        for i, (k, v) in enumerate(sorted(self._registry[interface].items())):
             
             # Get the module corresponding to the job class.
             mod = inspect.getmodule(v)
@@ -185,8 +161,8 @@ class ClassRegistry(abc.ABCMeta):
                     
         return contents.format(maxlength,*words)
 
-    @classmethod
-    def get_interfaces(cls):
+    @property
+    def interfaces(self):
         '''
         Returns the interfaces that are currently registered.
         
@@ -194,4 +170,8 @@ class ClassRegistry(abc.ABCMeta):
         :rtype: list of str
         '''
         
-        return sorted(cls._registry.keys())
\ No newline at end of file
+        return sorted(self._registry.keys())
+        
+REGISTRY = ClassRegistry()
+
+                

MDANSE/Data/ElementsDatabase.py

@@ -35,6 +35,8 @@ import copy
 import csv
 import numbers
 import os
+import pkg_resources
+import sys
 import xml.etree.ElementTree as etree
 
 from MDANSE.Core.Platform import PLATFORM
@@ -111,8 +113,14 @@ class ElementsDatabase(object):
     
     __metaclass__ = Singleton
     
-    # The default path
-    _DEFAULT_DATABASE = os.path.join(os.path.dirname(__file__), "elements_database.csv")
+    try:  
+        _DEFAULT_DATABASE = pkg_resources.resource_filename(__name__,"elements_database.csv")
+    except:  
+        if hasattr(sys,'frozen'):
+            _DEFAULT_DATABASE = os.path.join(os.path.dirname(sys.executable),"elements_database.csv")
+        else:
+            raise
+
 
     # The user path
     _USER_DATABASE = os.path.join(PLATFORM.application_directory(), "elements_database.csv")

MDANSE/Externals/__init__.py

@@ -28,7 +28,6 @@
 This package contains all the externals dependencies of MDANSE. It contains:
 
     #. magnitude: a package for handling units
-    #. pubsub: a package that implements the publisher subscriber mechanism
     #. pyparsing: a package for creating and executing simple grammar
     #. svgfig: a package for handling SVG file format
 

MDANSE/Externals/pubsub/LICENSE_BSD_Simple.txt

-Copyright (c) since 2006, Oliver Schoenborn
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met: 
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer. 
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution. 
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-

MDANSE/Externals/pubsub/RELEASE_NOTES.txt

-For PyPubSub v3.3.0
-^^^^^^^^^^^^^^^^^^^^^
-
-* cleanup low-level API: exception classes, moved some out of pub module that did not 
-  belong there (clutter), move couple modules, 
-* completed the reference documentation
-* support installation via pip
-* follow some guidelines in some PEPs such as PEP 396 and PEP 8
-* support Python 2.6, 2.7, and 3.2 to 3.4a4 but drop support for Python <= 2.5
-
-For PyPubSub v3.2.0
-^^^^^^^^^^^^^^^^^^^
-
-This is a minor release for small improvements made (see docs/CHANGELOG.txt) 
-based on feedback from user community. In particular an XML reader for 
-topic specification contributed by Josh English. Also cleaned up the 
-documentation, updated the examples folder (available in source distribution
-as well as `online`_). 
-
-.. _online: https://sourceforge.net/p/pubsub/code/HEAD/tree/
-
-Only 3 changes to API (function names): 
-
-* renamed pub.getDefaultRootAllTopics to pub.getDefaultTopicTreeRoot
-* removed pub.importTopicTree: use pub.addTopicDefnProvider(source, format)
-* renamed pub.exportTopicTree to pub.exportTopicTreeSpec
-
-Oliver Schoenborn
-September 2013
-
-
-PyPubSub 3.1.2
-^^^^^^^^^^^^^^^^
-
-This is a minor release for small improvements made (see docs/CHANGELOG.txt) 
-based on feedback from user community. Also extended the documentation. See 
-pubsub.sourceforge.net for installation and usage. See the examples folder for 
-some useful examples. 
-
-Oliver Schoenborn
-Nov 2011
-
-
-PyPubSub 3.1.1b1
-^^^^^^^^^^^^^^^^^^
-
-Docs updated. 
-
-Oliver Schoenborn
-May 2010
-
-
-For PyPubSub v3.1.0b1
-^^^^^^^^^^^^^^^^^^^^^^
-
-Major cleanup of the API since 3.0 and better support 
-for the legacy wxPython code. Defining a topic tree 
-via a text file has been improved drastically, making it
-simpler to document topic messages and payload data
-required or optional. More examples have been added, 
-and the messaging protocols clarified. 
-
-The included docs are not yet updated, that's what I'm 
-working on now and will lead to the 3.1.1b1 release. 
-I'm also working on an add-on module that would allow 
-two applications to communicate over the network using 
-pubsub-type messaging (with topics, etc). The design 
-is almost complete. 
-
-Oliver Schoenborn
-Jan 2010
\ No newline at end of file

MDANSE/Externals/pubsub/__init__.py

-"""
-Pubsub package initialization. 
+'''
+Publish-subscribe package.
 
-:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
-:license: BSD, see LICENSE_BSD_Simple.txt for details.
-"""
+This package provides the following modules:
 
-_PREVIOUS_RELEASE_DATE = "2013-09-15"
-_PREVIOUS_RELEASE_VER = "3.2.1b"
+- pub: "entry point" module for core pubsub functionality. It provides 
+  functions for sending messages and subscribing listeners and various
+  others.
+- utils: subpackage of utility functions and classes for debugging
+  messages, handling exceptions raised in listeners, and more.
+- setupv1: (deprecated) module to force pubsub to use the old,
+  "version 1" (aka v1) API (should only be useful to wxPython users
+  for legacy code).
+- setuparg1: module to setup pubsub to use "arg1" messaging protocol
+- setupkwargs: module to setup pubsub to use "kwargs" messaging protocol
+
+For instance::
+
+    from pubsub import pub
+    pub.sendMessage('topic', data1=123)
+
+:copyright: Copyright 2006-2009 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE.txt for details.
+
+Last known commit:
+- $Date: 2010-02-13 08:57:21 -0500 (Sat, 13 Feb 2010) $
+- $Revision: 249 $
+
+'''
 
-__version__ = "3.3.0"
 
 __all__ = [
-    'pub',
-    'utils',
-    'setupkwargs',
-    'setuparg1',
-    '__version__'
+    'pub', 'utils',
+    'printImported', 'setupkwargs', 'setuparg1', 'setupv1',
     ]
 
+# set our module search path in globalsettings so setup*.py modules 
+# can find and modify
+from MDANSE.Externals.pubsub import pubsubconf
+pubsubconf.setPubsubInfo(__path__, globals())
+#del pubsubconf # prevent circular ref
+
+
+def printImported():
+    '''Output a list of pubsub modules imported so far'''
+    import sys
+    ll = [mod for mod in sys.modules.keys() if mod.find('pubsub') >= 0]
+    ll.sort()
+    print '\n'.join(ll)
+
+
+def _tryAutoSetupV1():
+    '''This function is called automatically when the pubsub module is 
+    imported. It determines if the legacy "version 1" API of pubsub should
+    be used automatically, by looking for a module called 'autosetuppubsubv1'
+    on the module's search path. If this module is found, setupv1 is imported,
+    so your application will get v1 API just by doing "from pubsub import ...". 
+    If that module is not found then nothing happens and the function
+    returns; your application will get the "default" API unless you 
+    explicitly choose a different one. Note that autosetuppubsubv1 is never
+    actually imported, just searched. '''
+    try: 
+        # if autosetupv1 is importable, then it means we should
+        # automatically setup for version 1 API
+        import imp
+        imp.find_module('autosetuppubsubv1', __path__)
+        
+    except ImportError:
+        pass
+        
+    else:
+        from MDANSE.Externals.pubsub import setupv1
+        assert pub is not None
+        assert Publisher is pub.Publisher
+
+
+_tryAutoSetupV1()

MDANSE/Externals/pubsub/autosetuppubsubv1.py

+'''
+If this module is named autosetuppubsubv1, and it is in the pubsub
+package's folder, it will cause pubsub to default to "version 1" (v1)
+of the API when pub is imported. The v1 API was the version originally
+developed as part of wxPython's wx.lib library.
+
+If this module is named anything else (such as prefixed with an
+underscore) it will not be found by pubsub: the most recent pubsub
+API will be loaded upon import of the *pub* module.
+'''
\ No newline at end of file

MDANSE/Externals/pubsub/core/__init__.py

-"""
+'''
 Core package of pubsub, holding the publisher, listener, and topic
 object modules. Functions defined here are used internally by
 pubsub so that the right modules can be found later, based on the
@@ -11,7 +11,7 @@ protocol than for the arg1 protocol.
 
 The most convenient way to
 support this is to put the parts of the package that differ based
-on protocol in separate folder, and add one of those folders to
+on protocol in separate folders, and add one of those folders to
 the package's __path__ variable (defined automatically by the Python
 interpreter when __init__.py is executed). For instance, code
 specific to the kwargs protocol goes in the kwargs folder, and code
@@ -23,70 +23,54 @@ Only one protocol can be used in an application. The default protocol,
 if none is chosen by user, is kwargs, as selected by the call to
 _prependModulePath() at end of this file. 
 
-:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
-:license: BSD, see LICENSE_BSD_Simple.txt for details.
+:copyright: Copyright 2006-2009 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE.txt for details.
 
-"""
+'''
+
+from MDANSE.Externals.pubsub.core import policies
+
+def setMsgProtocol(protocol):
+    
+    policies.msgDataProtocol = protocol
+
+    # add appropriate subdir for protocol-specific implementation
+    if protocol == 'kwargs':
+        _replaceModulePath0('kwargs')
+    else:
+        _replaceModulePath0('arg1')
+
+
+def setMsgDataArgName(stage, listenerArgName, senderArgNameAny=False):
+
+    policies.senderKwargNameAny = senderArgNameAny
+    policies.msgDataArgName = listenerArgName
+    policies.msgProtocolTransStage = stage
+    #print `policies.msgProtocolTransStage`, `policies.msgDataProtocol`, \
+    #      `policies.senderKwargNameAny`, `policies.msgDataArgName`
+    #print 'override "arg1" protocol arg name:', argName
+
+
+def _replaceModulePath0(dirname):
+    '''Replace the first package-path item (in __path__) with dirname.
+    The dirname will be prepended with the package's path, assumed to
+    be the last item in __path__.'''
+    corepath = __path__
+    assert len(corepath) > 1
+    initpyLoc = corepath[-1]
+    import os
+    corepath[0] = os.path.join(initpyLoc, dirname)
 
 
 def _prependModulePath(extra):
-    """Insert extra at beginning of package's path list. Should only be
+    '''Insert extra at beginning of package's path list. Should only be
     called once, at package load time, to set the folder used for
-    implementation specific to the default message protocol."""
+    implementation specific to the default message protocol.'''
     corepath = __path__
     initpyLoc = corepath[-1]
     import os
     corepath.insert(0, os.path.join(initpyLoc, extra))
     
-# add appropriate subdir for protocol-specific implementation
-from .. import policies
-_prependModulePath(policies.msgDataProtocol)
-
-from .publisher import Publisher
-
-from .callables import (
-    AUTO_TOPIC,
-)
-
-from .listener import (
-    Listener,
-    getID as getListenerID,
-    ListenerMismatchError,
-    IListenerExcHandler,
-)
-
-from .topicobj import (
-    Topic,
-    SenderMissingReqdMsgDataError, 
-    SenderUnknownMsgDataError, 
-    MessageDataSpecError, 
-    TopicDefnError, 
-    ExcHandlerError,
-)
-
-from .topicmgr import (
-    TopicManager, 
-    TopicDefnError,
-    TopicNameError,
-    ALL_TOPICS,
-)
-
-from .topicdefnprovider import (
-    ITopicDefnProvider,
-    TopicDefnProvider,
-    ITopicDefnDeserializer,
-    UnrecognizedSourceFormatError, 
-    
-    exportTopicTreeSpec,
-    TOPIC_TREE_FROM_MODULE,
-    TOPIC_TREE_FROM_STRING,
-    TOPIC_TREE_FROM_CLASS, 
-)
-
-from .topictreetraverser import (
-    TopicTreeTraverser,
-)
-
-from .notificationmgr import (
-    INotificationHandler,
-)
\ No newline at end of file
+
+# default protocol:
+_prependModulePath('kwargs')

MDANSE/Externals/pubsub/core/arg1/__init__.py

-"""
+'''
 This is not really a package init file, it is only here to simplify the
 packaging and installation of pubsub.core's protocol-specific subfolders
 by setuptools.  The python modules in this folder are automatically made
@@ -6,10 +6,10 @@ part of pubsub.core via pubsub.core's __path__. Hence, this should not
 be imported directly, it is part of pubsub.core when the messaging
 protocol is "arg1" (and not usable otherwise).
 
-:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
-:license: BSD, see LICENSE_BSD_Simple.txt for details.
+:copyright: Copyright 2006-2009 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE.txt for details.
 
-"""
+'''
 
 
 msg = 'Should not import this directly, used by pubsub.core if applicable'

MDANSE/Externals/pubsub/core/arg1/listenerimpl.py

-"""
-:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
-:license: BSD, see LICENSE_BSD_Simple.txt for details.
-"""
+'''
 
-from .listenerbase import (ListenerBase, ValidatorBase)
-from .callables import ListenerMismatchError
-from .. import policies
+:copyright: Copyright 2006-2009 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE.txt for details.
+
+'''
+
+from MDANSE.Externals.pubsub.core.listenerbase import ListenerBase, ValidatorBase, ListenerInadequate
+from MDANSE.Externals.pubsub.core.callables import ListenerInadequate
+from MDANSE.Externals.pubsub.core import policies
 
 
 class Message:
     """
     A simple container object for the two components of a topic messages
-    in the pubsub legacy API: the
+    in the pubsub API v1: the
     topic and the user data. An instance of Message is given to your
     listener when called by sendMessage(topic). The data is accessed
     via the 'data' attribute, and can be type of object.
@@ -21,26 +23,14 @@ class Message:
         self.data  = data
 
     def __str__(self):
-        return '[Topic: '+repr(self.topic)+',  Data: '+repr(self.data)+']'
+        return '[Topic: '+`self.topic`+',  Data: '+`self.data`+']'
 
 
 class Listener(ListenerBase):
-    """
-    Wraps a callable so it can be stored by weak reference and introspected
-    to verify that it adheres to a topic's MDS. 
-    
-    A Listener instance has the same hash value as the callable that it wraps. 
-
-    A callable will be given data when a message is sent to it. In the arg1 
-    protocol only one object can be sent via sendMessage, it is put in a 
-    Message object in its "data" field, the listener receives the Message 
-    object. 
-    """
-    
     def __call__(self, actualTopic, data):
-        """Call the listener with data. Note that it raises RuntimeError
+        '''Call the listener with data. Note that it raises RuntimeError 
         if listener is dead. Should always return True (False would require
-        the callable_ be dead but self hasn't yet been notified of it...)."""
+        the callable_ be dead but self hasn't yet been notified of it...).'''
         kwargs = {}
         if self._autoTopicArgName is not None:
             kwargs[self._autoTopicArgName] = actualTopic
@@ -53,11 +43,11 @@ class Listener(ListenerBase):
 
 
 class ListenerValidator(ValidatorBase):
-    """
+    '''
     Accept one arg or *args; accept any **kwarg, 
     and require that the Listener have at least all the kwargs (can 
     have extra) of Topic.
-    """
+    '''
     
     def _validateArgs(self, listener, paramsInfo):
         # accept **kwargs
@@ -69,7 +59,7 @@ class ListenerValidator(ValidatorBase):
 
         if paramsInfo.getAllArgs() == ():
             msg = 'Must have at least one parameter (any name, with or without default value, or *arg)'
-            raise ListenerMismatchError(msg, listener, [])
+            raise ListenerInadequate(msg, listener, [])
 
         assert paramsInfo.getAllArgs()
         #assert not paramsInfo.acceptsAllUnnamedArgs
@@ -79,7 +69,7 @@ class ListenerValidator(ValidatorBase):
         if numReqdArgs > 1:
             allReqd = paramsInfo.getRequiredArgs()
             msg = 'only one of %s can be a required agument' % (allReqd,)
-            raise ListenerMismatchError(msg, listener, allReqd)