wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/lib/pubsub/core/callables.py

@@ -0,0 +1,191 @@
+"""
+Low level functions and classes related to callables.
+
+The AUTO_TOPIC
+is the "marker" to use in callables to indicate that when a message
+is sent to those callables, the topic object for that message should be
+added to the data sent via the call arguments. See the docs in
+CallArgsInfo regarding its autoTopicArgName data member.
+
+:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE_BSD_Simple.txt for details.
+
+"""
+
+from inspect import getargspec, ismethod, isfunction
+
+from .. import py2and3
+
+AUTO_TOPIC    = '## your listener wants topic name ## (string unlikely to be used by caller)'
+
+
+def getModule(obj):
+    """Get the module in which an object was defined. Returns '__main__'
+    if no module defined (which usually indicates either a builtin, or
+    a definition within main script). """
+    if hasattr(obj, '__module__'):
+        module = obj.__module__
+    else:
+        module = '__main__'
+    return module
+
+
+def getID(callable_):
+    """Get name and module name for a callable, ie function, bound
+    method or callable instance, by inspecting the callable. E.g.
+    getID(Foo.bar) returns ('Foo.bar', 'a.b') if Foo.bar was
+    defined in module a.b. """
+    sc = callable_
+    if ismethod(sc):
+        module = getModule(sc.__self__)
+        id = '%s.%s' % (sc.__self__.__class__.__name__, sc.__func__.__name__)
+    elif isfunction(sc):
+        module = getModule(sc)
+        id = sc.__name__
+    else: # must be a functor (instance of a class that has __call__ method)
+        module = getModule(sc)
+        id = sc.__class__.__name__
+
+    return id, module
+
+
+def getRawFunction(callable_):
+    """Given a callable, return (offset, func) where func is the
+    function corresponding to callable, and offset is 0 or 1 to
+    indicate whether the function's first argument is 'self' (1)
+    or not (0). Raises ValueError if callable_ is not of a
+    recognized type (function, method or has __call__ method)."""
+    firstArg = 0
+    if isfunction(callable_):
+        #print 'Function', getID(callable_)
+        func = callable_
+    elif ismethod(callable_):
+        #print 'Method', getID(callable_)
+        func = callable_
+        if func.__self__ is not None:
+            # Method is bound, don't care about the self arg
+            firstArg = 1
+    elif hasattr(callable_, '__call__'):
+        #print 'Functor', getID(callable_)
+        func = callable_.__call__
+        firstArg = 1  # don't care about the self arg
+    else:
+        msg = 'type "%s" not supported' % type(callable_).__name__
+        raise ValueError(msg)
+
+    return func, firstArg
+
+
+class ListenerMismatchError(ValueError):
+    """
+    Raised when an attempt is made to subscribe a listener to
+    a topic, but listener does not satisfy the topic's message data
+    specification (MDS). This specification is inferred from the first
+    listener subscribed to a topic, or from an imported topic tree
+    specification (see pub.addTopicDefnProvider()).
+    """
+
+    def __init__(self, msg, listener, *args):
+        idStr, module = getID(listener)
+        msg = 'Listener "%s" (from module "%s") inadequate: %s' % (idStr, module, msg)
+        ValueError.__init__(self, msg)
+        self.msg    = msg
+        self.args   = args
+        self.module = module
+        self.idStr  = idStr
+
+    def __str__(self):
+        return self.msg
+
+
+class CallArgsInfo:
+    """
+    Represent the "signature" or protocol of a listener in the context of
+    topics.
+    """
+
+    def __init__(self, func, firstArgIdx): #args, firstArgIdx, defaultVals, acceptsAllKwargs=False):
+        """Inputs:
+        - Args and defaultVals are the complete set of arguments and
+          default values as obtained form inspect.getargspec();
+        - The firstArgIdx points to the first item in
+          args that is of use, so it is typically 0 if listener is a function,
+          and 1 if listener is a method.
+        - The acceptsAllKwargs should be true
+          if the listener has **kwargs in its protocol.
+
+        After construction,
+        - self.allParams will contain the subset of 'args' without first
+          firstArgIdx items,
+        - self.numRequired will indicate number of required arguments
+          (ie self.allParams[:self.numRequired] are the required args names);
+        - self.acceptsAllKwargs = acceptsAllKwargs
+        - self.autoTopicArgName will be the name of argument
+          in which to put the topic object for which pubsub message is
+          sent, or None. This is identified by the argument that has a
+          default value of AUTO_TOPIC.
+
+        For instance, listener(self, arg1, arg2=AUTO_TOPIC, arg3=None) will
+        have self.allParams = (arg1, arg2, arg3), self.numRequired=1, and
+        self.autoTopicArgName = 'arg2', whereas
+        listener(self, arg1, arg3=None) will have
+        self.allParams = (arg1, arg3), self.numRequired=1, and
+        self.autoTopicArgName = None."""
+
+        #args, firstArgIdx, defaultVals, acceptsAllKwargs
+        (allParams, varParamName, varOptParamName, defaultVals) = getargspec(func)
+        if defaultVals is None:
+            defaultVals = []
+        else:
+            defaultVals = list(defaultVals)
+
+        self.acceptsAllKwargs      = (varOptParamName is not None)
+        self.acceptsAllUnnamedArgs = (varParamName    is not None)
+
+        self.allParams = allParams
+        del self.allParams[0:firstArgIdx] # does nothing if firstArgIdx == 0
+
+        self.numRequired = len(self.allParams) - len(defaultVals)
+        assert self.numRequired >= 0
+
+        # if listener wants topic, remove that arg from args/defaultVals
+        self.autoTopicArgName = None
+        if defaultVals:
+            self.__setupAutoTopic(defaultVals)
+
+    def getAllArgs(self):
+        return tuple( self.allParams )
+
+    def getOptionalArgs(self):
+        return tuple( self.allParams[self.numRequired:] )
+
+    def getRequiredArgs(self):
+        """Return a tuple of names indicating which call arguments
+        are required to be present when pub.sendMessage(...) is called. """
+        return tuple( self.allParams[:self.numRequired] )
+
+    def __setupAutoTopic(self, defaults):
+        """Does the listener want topic of message? Returns < 0 if not,
+        otherwise return index of topic kwarg within args."""
+        for indx, defaultVal in enumerate(defaults):
+            if defaultVal == AUTO_TOPIC:
+                #del self.defaults[indx]
+                firstKwargIdx = self.numRequired
+                self.autoTopicArgName = self.allParams.pop(firstKwargIdx + indx)
+                break
+
+
+def getArgs(callable_):
+    """Returns an instance of CallArgsInfo for the given callable_.
+    Raises ListenerMismatchError if callable_ is not a callable."""
+    # figure out what is the actual function object to inspect:
+    try:
+        func, firstArgIdx = getRawFunction(callable_)
+    except ValueError:
+        from .. import py2and3
+        exc = py2and3.getexcobj()
+        raise ListenerMismatchError(str(exc), callable_)
+
+    return CallArgsInfo(func, firstArgIdx)
+
+

wx/lib/pubsub/core/imp2.py

@@ -0,0 +1,63 @@
+"""
+The _resolve_name and _import_module were taken from the backport of 
+importlib.import_module from 3.x to 2.7. Thanks to the Python developers
+for making this available as a standalone module. This makes it possible
+to have an import module that mimics the "import" statement more
+closely.
+"""
+
+import sys
+from .. import py2and3
+
+def _resolve_name(name, package, level):
+    """Return the absolute name of the module to be imported."""
+    if not hasattr(package, 'rindex'):
+        raise ValueError("'package' not set to a string")
+    dot = len(package)
+    for x in py2and3.xrange(level, 1, -1):
+        try:
+            dot = package.rindex('.', 0, dot)
+        except ValueError:
+            raise ValueError("attempted relative import beyond top-level "
+                              "package")
+    return "%s.%s" % (package[:dot], name)
+
+
+def _import_module(name, package=None):
+    """Import a module.
+
+    The 'package' argument is required when performing a relative import. It
+    specifies the package to use as the anchor point from which to resolve the
+    relative import to an absolute import.
+    """
+    if name.startswith('.'):
+        if not package:
+            raise TypeError("relative imports require the 'package' argument")
+        level = 0
+        for character in name:
+            if character != '.':
+                break
+            level += 1
+        name = _resolve_name(name[level:], package, level)
+    __import__(name)
+    return sys.modules[name]
+
+    
+def load_module(moduleName, searchPath):
+    """Try to import moduleName. If this doesn't work, use the "imp" module
+    that is part of Python. """
+    try: 
+        module = _import_module(moduleName) 
+        
+    except:
+        import imp
+        fp, pathname, description = imp.find_module(moduleName, searchPath)
+        try:
+            module = imp.load_module(moduleName, fp, pathname, description)
+            
+        finally:
+            # Since we may exit via an exception, close fp explicitly.
+            if fp:
+                fp.close()
+                
+    return module

wx/lib/pubsub/core/kwargs/__init__.py

@@ -0,0 +1,16 @@
+"""
+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 "kwargs" (and not usable otherwise).
+
+:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE_BSD_Simple.txt for details.
+
+"""
+
+
+msg = 'Should not import this directly, used by pubsub.core if applicable'
+raise RuntimeError(msg)

wx/lib/pubsub/core/kwargs/datamsg.py

@@ -0,0 +1,27 @@
+"""
+:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE_BSD_Simple.txt for details.
+"""
+
+class Message:
+    """
+    A simple container object for the two components of a message in the 
+    arg1 messaging protocol: the 
+    topic and the user data. Each listener called by sendMessage(topic, data)
+    gets an instance of Message. The given 'data' is accessed
+    via Message.data, while the topic name is available in Message.topic::
+    
+        def listener(msg):
+            print "data is ", msg.data
+            print "topic name is ", msg.topic
+            print msg
+            
+    The example also shows (last line) how a message is convertible to a string.
+    """
+    def __init__(self, topic, data):
+        self.topic = topic
+        self.data  = data
+
+    def __str__(self):
+        return '[Topic: '+repr(self.topic)+',  Data: '+repr(self.data)+']'
+

wx/lib/pubsub/core/kwargs/listenerimpl.py

@@ -0,0 +1,93 @@
+"""
+
+: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
+
+
+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. 
+
+    Callables that have 'argName=pub.AUTO_TOPIC' as a kwarg will
+    be given the Topic object for the message sent by sendMessage().
+    Such a Listener will have wantsTopicObjOnCall() True.
+    
+    Callables that have a '\**kargs' argument will receive all message
+    data, not just that for the topic they are subscribed to. Such a listener
+    will have wantsAllMessageData() True. 
+    """
+    
+    def __call__(self, kwargs, actualTopic, allKwargs=None):
+        """Call the listener with **kwargs. 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...)."""
+        if self.acceptsAllKwargs:
+            kwargs = allKwargs or kwargs # if allKwargs is None then use kwargs
+
+        if self._autoTopicArgName is not None:
+            kwargs = kwargs.copy()
+            kwargs[self._autoTopicArgName] = actualTopic
+
+        cb = self._callable()
+        if cb is None:
+            self._calledWhenDead()
+        cb(**kwargs)
+
+        return True
+
+
+class ListenerValidator(ValidatorBase):
+    """
+    Do not accept any required args 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
+        
+        # check if listener missing params (only possible if
+        # paramsInfo.acceptsAllKwargs is False)
+        allTopicMsgArgs = self._topicArgs | self._topicKwargs
+        allParams = set(paramsInfo.allParams)
+        if not paramsInfo.acceptsAllKwargs:
+            missingParams = allTopicMsgArgs - allParams
+            if missingParams:
+                msg = 'needs to accept %s more args (%s)' \
+                    % (len(missingParams), ''.join(missingParams))
+                raise ListenerMismatchError(msg, listener, missingParams)
+        else:
+            # then can accept that some parameters missing from listener 
+            # signature
+            pass
+            
+        # check if there are unknown parameters in listener signature:
+        extraArgs = allParams - allTopicMsgArgs
+        if extraArgs:
+            if allTopicMsgArgs:
+                msg = 'args (%s) not allowed, should be (%s)' \
+                    % (','.join(extraArgs), ','.join(allTopicMsgArgs))
+            else:
+                msg = 'no args allowed, has (%s)' % ','.join(extraArgs)
+            raise ListenerMismatchError(msg, listener, extraArgs)
+
+        # we accept listener that has fewer required paams than TMS
+        # since all args passed by name (previous showed that spec met
+        # for all parameters).
+
+        # now make sure listener doesn't require params that are optional in TMS:
+        extraArgs = set( paramsInfo.getRequiredArgs() ) - self._topicArgs
+        if extraArgs:
+            msg = 'params (%s) missing default values' % (','.join(extraArgs),)
+            raise ListenerMismatchError(msg, listener, extraArgs)
+

wx/lib/pubsub/core/kwargs/publisher.py

@@ -0,0 +1,77 @@
+"""
+:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE_BSD_Simple.txt for details.
+"""
+
+
+from .publisherbase import PublisherBase
+from .datamsg import Message
+from .. import (policies, py2and3)
+
+
+
+class Publisher(PublisherBase):
+    """
+    Publisher used for kwargs protocol, ie when sending message data
+    via keyword arguments.
+    """
+
+    def sendMessage(self, topicName, **kwargs):
+        """Send a message.
+
+        :param topicName: name of message topic (dotted or tuple format)
+        :param kwargs: message data (must satisfy the topic's MDS)
+        """
+        topicMgr = self.getTopicMgr()
+        topicObj = topicMgr.getOrCreateTopic(topicName)
+        topicObj.publish(**kwargs)
+
+    def getMsgProtocol(self):
+        return 'kwargs'
+
+
+class PublisherArg1Stage2(Publisher):
+    """
+    This is used when transitioning from arg1 to kwargs
+    messaging protocol.
+    """
+
+    _base = Publisher
+    
+    class SenderTooManyKwargs(RuntimeError):
+        def __init__(self, kwargs, commonArgName):
+            extra = kwargs.copy()
+            del extra[commonArgName]
+            msg = 'Sender has too many kwargs (%s)' % ( py2and3.keys(extra),)
+            RuntimeError.__init__(self, msg)
+
+    class SenderWrongKwargName(RuntimeError):
+        def __init__(self, actualKwargName, commonArgName):
+            msg = 'Sender uses wrong kwarg name ("%s" instead of "%s")' \
+                % (actualKwargName, commonArgName)
+            RuntimeError.__init__(self, msg)
+
+    def __init__(self, treeConfig = None):
+        self._base.__init__(self, treeConfig)
+        self.Msg = Message
+
+    def sendMessage(self, _topicName, **kwarg):
+        commonArgName = policies.msgDataArgName
+        if len(kwarg) > 1:
+            raise self.SenderTooManyKwargs(kwarg, commonArgName)
+        elif len(kwarg) == 1 and commonArgName not in kwarg:
+            raise self.SenderWrongKwargName( py2and3.keys(kwarg)[0], commonArgName)
+
+        data = kwarg.get(commonArgName, None)
+        kwargs = { commonArgName: self.Msg( _topicName, data) }
+        self._base.sendMessage( self, _topicName, **kwargs )
+
+    def getMsgProtocol(self):
+        return 'kwarg1'
+
+
+if policies.msgProtocolTransStage is not None:
+    Publisher = PublisherArg1Stage2
+    #print 'Using protocol', Publisher
+
+

wx/lib/pubsub/core/kwargs/publishermixin.py

@@ -0,0 +1,65 @@
+"""
+:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE_BSD_Simple.txt for details.
+"""
+
+
+class PublisherMixin:
+    """
+    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).
+    """
+
+    def __init__(self):
+        pass
+
+    def publish(self, **msgKwargs):
+        self._publish(msgKwargs)
+
+    ############## IMPLEMENTATION ###############
+    
+    class IterState:
+        def __init__(self, msgKwargs):
+            self.filteredArgs = msgKwargs
+            self.argsChecked = False
+
+        def checkMsgArgs(self, spec):
+            spec.check(self.filteredArgs)
+            self.argsChecked = True
+
+        def filterMsgArgs(self, topicObj):
+            if self.argsChecked:
+                self.filteredArgs = topicObj.filterMsgArgs(self.filteredArgs)
+            else:
+                self.filteredArgs = topicObj.filterMsgArgs(self.filteredArgs, True)
+                self.argsChecked = True
+
+    def _mix_prePublish(self, msgKwargs, topicObj=None, iterState=None):
+        if iterState is None:
+            # do a first check that all args are there, costly so only do once
+            iterState = self.IterState(msgKwargs)
+            if self.hasMDS():
+                iterState.checkMsgArgs( self._getListenerSpec() )
+            else:
+                assert not self.hasListeners()
+
+        else:
+            iterState.filterMsgArgs(topicObj)
+
+        assert iterState is not None
+        return iterState
+
+    def _mix_callListener(self, listener, msgKwargs, iterState):
+        """Send the message for given topic with data in msgKwargs.
+        This sends message to listeners of parent topics as well.
+        Note that at each level, msgKwargs is filtered so only those
+        args that are defined for the topic are sent to listeners. """
+        listener(iterState.filteredArgs, self, msgKwargs)
+