Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Sign in
Toggle navigation
Menu
Open sidebar
Scientific Software
MDANSE
Commits
9e6d4dda
Commit
9e6d4dda
authored
Oct 14, 2016
by
eric pellegrini
Browse files
Refactored pubsub module with absolute import
parent
6ae23a48
Pipeline
#1089
failed with stages
in 2 minutes and 23 seconds
Changes
301
Pipelines
1
Hide whitespace changes
Inline
Side-by-side
MDANSE/Core/ClassRegistry.py
View file @
9e6d4dda
...
...
@@ -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
):
self
.
_registry
=
{}
self
.
_sections
=
{}
def
__setitem__
(
self
,
name
,
cls
):
_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
'''
# 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
super
(
ClassRegistry
,
self
).
__init__
(
name
,
bases
,
namespace
)
# If the class objet does not have a type attribute, it will not be registered.
typ
=
getattr
(
self
,
'type'
,
None
)
if
typ
is
None
:
# And this attribute must be a string for the class to be registerable otherwise return
if
not
isinstance
(
clsRegistry
,
basestring
):
return
# 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
,{})
# If a class has already been registered with that name return
if
d
.
has_key
(
name
):
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
)):
return
ClassRegistry
.
_registry
[
typ
]
=
{}
else
:
for
interface
in
ClassRegistry
.
__interfaces
:
if
issubclass
(
self
,
interface
):
ClassRegistry
.
_registry
[
interface
.
type
][
typ
]
=
self
break
@
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.
...
...
@@ -141,10 +119,8 @@ class ClassRegistry(abc.ABCMeta):
else
:
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
View file @
9e6d4dda
...
...
@@ -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/pubsub/__init__.py
0 → 100644
View file @
9e6d4dda
'''
Publish-subscribe package.
This package provides the following modules:
- 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 $
'''
__all__
=
[
'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
0 → 100644
View file @
9e6d4dda
'''
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
0 → 100644
View file @
9e6d4dda
'''
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
selected messaging protocol.
Indeed some of the API depends on the messaging
protocol used. For instance sendMessage(), defined in publisher.py,
has a different signature (and hence implementation) for the kwargs
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 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
specific to the arg1 protocol in the arg1 folder. Then when doing
"from pubsub.core import listener", the correct listener.py will be
found for the specified protocol. The default protocol is kwargs.
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 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
called once, at package load time, to set the folder used for
implementation specific to the default message protocol.'''
corepath
=
__path__
initpyLoc
=
corepath
[
-
1
]
import
os
corepath
.
insert
(
0
,
os
.
path
.
join
(
initpyLoc
,
extra
))
# default protocol:
_prependModulePath
(
'kwargs'
)
MDANSE/Externals/pubsub/core/arg1/__init__.py
0 → 100644
View file @
9e6d4dda
'''
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
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 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'
raise
RuntimeError
(
msg
)
\ No newline at end of file
MDANSE/Externals/pubsub/core/arg1/listenerimpl.py
0 → 100644
View file @
9e6d4dda
'''
: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 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.
"""
def
__init__
(
self
,
topicNameTuple
,
data
):
self
.
topic
=
topicNameTuple
self
.
data
=
data
def
__str__
(
self
):
return
'[Topic: '
+
`self.topic`
+
', Data: '
+
`self.data`
+
']'
class
Listener
(
ListenerBase
):
def
__call__
(
self
,
actualTopic
,
data
):
'''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...).'''
kwargs
=
{}
if
self
.
_autoTopicArgName
is
not
None
:
kwargs
[
self
.
_autoTopicArgName
]
=
actualTopic
cb
=
self
.
_callable
()
if
cb
is
None
:
self
.
_calledWhenDead
()
msg
=
Message
(
actualTopic
.
getNameTuple
(),
data
)
cb
(
msg
,
**
kwargs
)
return
True
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
# accept *args
# accept any keyword args
if
(
paramsInfo
.
getAllArgs
()
==
())
and
paramsInfo
.
acceptsAllUnnamedArgs
:
return
if
paramsInfo
.
getAllArgs
()
==
():
msg
=
'Must have at least one parameter (any name, with or without default value, or *arg)'
raise
ListenerInadequate
(
msg
,
listener
,
[])
assert
paramsInfo
.
getAllArgs
()
#assert not paramsInfo.acceptsAllUnnamedArgs
# verify at most one required arg
numReqdArgs
=
paramsInfo
.
numRequired
if
numReqdArgs
>
1
:
allReqd
=
paramsInfo
.
getRequiredArgs
()
msg
=
'only one of %s can be a required agument'
%
(
allReqd
,)
raise
ListenerInadequate
(
msg
,
listener
,
allReqd
)
# if no required args but listener has *args, then we
# don't care about anything else:
if
numReqdArgs
==
0
and
paramsInfo
.
acceptsAllUnnamedArgs
:
return
# if no policy set, any name ok; otherwise validate name:
needArgName
=
policies
.
msgDataArgName
firstArgName
=
paramsInfo
.
allParams
[
0
]
if
(
needArgName
is
not
None
)
and
firstArgName
!=
needArgName
:
msg
=
'listener arg name must be "%s" (is "%s")'
%
(
needArgName
,
firstArgName
)
effTopicArgs
=
[
needArgName
]
raise
ListenerInadequate
(
msg
,
listener
,
effTopicArgs
)
MDANSE/Externals/pubsub/core/arg1/publisher.py
0 → 100644
View file @
9e6d4dda
'''
Mixin for publishing messages to a topic's listeners. This will be
mixed into topicobj.Topic so that a user can use a Topic object to
send a message to the topic's listeners via a publish() method.
:copyright: Copyright 2006-2009 by Oliver Schoenborn, all rights reserved.
:license: BSD, see LICENSE.txt for details.
'''
from
MDANSE.Externals.pubsub.core.publisherbase
import
PublisherBase
class
Publisher
(
PublisherBase
):
'''
Publisher that allows old-style Message.data messages to be sent
to listeners. Listeners take one arg (required, unless there is an
*arg), but can have kwargs (since they have default values).
'''
def
sendMessage
(
self
,
topicName
,
data
=
None
):
'''Send message of type topicName to all subscribed listeners,
with message data. If topicName is a subtopic, listeners
of topics more general will also get the message.
Note that any listener that lets a raised exception escape will
interrupt the send operation, unless an exception handler was
specified via pub.setListenerExcHandler().
'''
topicMgr
=
self
.
getTopicMgr
()
topicObj
=
topicMgr
.
getOrCreateTopic
(
topicName
)
# don't care if topic not final: topicObj.getListeners()
# will return nothing if not final but notification will still work
topicObj
.
publish
(
data
)
def
getMsgProtocol
(
self
):
return
'arg1'
MDANSE/Externals/pubsub/core/arg1/publishermixin.py
0 → 100644
View file @
9e6d4dda
'''
Mixin for publishing messages to a topic's listeners. This will be
mixed into topicobj.Topic so that a user can use a Topic object to
send a message to the topic's listeners via a publish() method.
Note that it is important that the PublisherMixin NOT modify any
state data during message sending, because in principle it could
happen that a listener causes another message of same topic to be
sent (presumably, the listener has a way of preventing infinite
loop).
:copyright: Copyright 2006-2009 by Oliver Schoenborn, all rights reserved.
:license: BSD, see LICENSE.txt for details.
'''
class
PublisherMixin
:
def
__init__
(
self
):
pass
def
publish
(
self
,
data
=
None
):
self
.
_publish
(
data
)
############## IMPLEMENTATION ###############
def
_mix_prePublish
(
self
,
data
,
topicObj
=
None
,
iterState
=
None
):
'''Called just before the __sendMessage, to perform any argument
checking, set iterState, etc'''
return
None
def
_mix_callListener
(
self
,
listener
,
data
,
iterState
):
'''Send the data to given listener.'''
listener
(
self
,
data
)
MDANSE/Externals/pubsub/core/arg1/topicargspecimpl.py
0 → 100644
View file @
9e6d4dda
'''
:copyright: Copyright 2006-2009 by Oliver Schoenborn, all rights reserved.
:license: BSD, see LICENSE.txt for details.
'''
import
weakref
from
MDANSE.Externals.pubsub.core.topicutils
import
WeakNone
class
SenderMissingReqdArgs
(
RuntimeError
):
'''
Ignore: Not used for this message protocol.
'''
pass
class
SenderUnknownOptArgs
(
RuntimeError
):
'''
Ignore: Not used for this message protocol.
'''
pass
class
ArgsInfo
:
'''
Encode the Listener Function Parameter Specification (LPS) for a given
topic. In the DataMsg API of pubsub, this is the same for all
topics, so this is quite a simple class, required only because
the part of pubsub that uses ArgsInfos supports several API
versions using one common API. So the only difference between
an ArgsInfo and an ArgSpecGiven is that ArgsInfo refers to
parent topic's ArgsInfo; other data members are the same.
Note that the LPS is always complete because it is known:
it consists of one required argument named 'data' and no
optional arguments.
'''
SPEC_MISSING
=
10
# no args given
SPEC_COMPLETE
=
12
# all args, but not confirmed via user spec
def
__init__
(
self
,
topicNameTuple
,
specGiven
,
parentArgsInfo
):
self
.
__argsDocs
=
specGiven
.
argsDocs
or
{
'data'
:
'message data'
}
self
.
argsSpecType
=
self
.
SPEC_COMPLETE
self
.
allOptional
=
()
# list of topic message optional argument names
self
.
allRequired
=
(
'data'
,)
# list of topic message required argument names
self
.
parentAI
=
WeakNone
()
if
parentArgsInfo
is
not
None
:
self
.
parentAI
=
weakref
.
ref
(
parentArgsInfo
)
def
isComplete
(
self
):
return
True
def
getArgs
(
self
):
return
self
.
allOptional
+
self
.
allRequired
def
numArgs
(
self
):
return
len
(
self
.
allOptional
)
+
len
(
self
.
allRequired
)
def
getArgsDocs
(
self
):
return
self
.
__argsDocs
.
copy
()
MDANSE/Externals/pubsub/core/arg1/topicmgrimpl.py
0 → 100644
View file @
9e6d4dda
'''
The root topic of all topics is different based on messaging protocol.
:copyright: Copyright 2006-2009 by Oliver Schoenborn, all rights reserved.
:license: BSD, see LICENSE.txt for details.