wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/lib/pubsub/core/topicutils.py

@@ -0,0 +1,118 @@
+"""
+Various utilities used by topic-related modules. 
+
+:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE_BSD_Simple.txt for details.
+
+"""
+
+from textwrap import TextWrapper, dedent
+
+from .topicexc import TopicNameError
+
+from .. import py2and3
+
+__all__ = []
+
+
+UNDERSCORE = '_' # topic name can't start with this
+# just want something unlikely to clash with user's topic names
+ALL_TOPICS = 'ALL_TOPICS'
+
+
+class WeakNone:
+    """Pretend to be a weak reference to nothing. Used by ArgsInfos to
+    refer to parent when None so no if-else blocks needed. """
+    def __call__(self):
+        return None
+
+
+def smartDedent(paragraph):
+    """Dedent paragraph using textwrap.dedent(), but properly dedents
+    even if the first line of paragraph does not contain blanks. 
+    This handles the case where a user types a documentation string as 
+        '''A long string spanning
+        several lines.'''
+    """
+    if paragraph.startswith(' '):
+        para = dedent(paragraph)
+    else:
+        lines = paragraph.split('\n')
+        exceptFirst = dedent('\n'.join(lines[1:]))
+        para = lines[0]+exceptFirst
+    return para
+
+
+import re
+_validNameRE = re.compile(r'[-0-9a-zA-Z]\w*')
+
+
+def validateName(topicName):
+    """Raise TopicNameError if nameTuple not valid as topic name."""
+    topicNameTuple = tupleize(topicName)
+    if not topicNameTuple:
+        reason = 'name tuple must have at least one item!'
+        raise TopicNameError(None, reason)
+
+    class topic: pass
+    for subname in topicNameTuple:
+        if not subname:
+            reason = 'can\'t contain empty string or None'
+            raise TopicNameError(topicNameTuple, reason)
+
+        if subname.startswith(UNDERSCORE):
+            reason = 'must not start with "%s"' % UNDERSCORE
+            raise TopicNameError(topicNameTuple, reason)
+
+        if subname == ALL_TOPICS:
+            reason = 'string "%s" is reserved for root topic' % ALL_TOPICS
+            raise TopicNameError(topicNameTuple, reason)
+
+        if _validNameRE.match(subname) is None:
+            reason = 'element #%s ("%s") has invalid characters' % \
+                (1+list(topicNameTuple).index(subname), subname)
+            raise TopicNameError(topicNameTuple, reason)
+
+
+def stringize(topicName):
+    """If topicName is a string, just return it
+    as is. If it is a topic definition object (ie an object that has 
+    'msgDataSpec' as data member), return the dotted name of corresponding
+    topic. Otherwise, assume topicName is a tuple and convert it to to a 
+    dotted name i.e. ('a','b','c') => 'a.b.c'. Empty name is not allowed 
+    (ValueError). The reverse operation is tupleize(topicName)."""
+    if py2and3.isstring(topicName):
+        return topicName
+    
+    if hasattr(topicName, "msgDataSpec"): 
+        return topicName._topicNameStr
+
+    try:
+        name = '.'.join(topicName)
+    except Exception:
+        exc = py2and3.getexcobj()
+        raise TopicNameError(topicName, str(exc))
+    
+    return name
+
+
+def tupleize(topicName):
+    """If topicName is a tuple of strings, just return it as is. Otherwise,
+    convert it to tuple, assuming dotted notation used for topicName. I.e. 
+    'a.b.c' => ('a','b','c'). Empty topicName is not allowed (ValueError). 
+    The reverse operation is stringize(topicNameTuple)."""
+    # assume name is most often str; if more often tuple, 
+    # then better use isinstance(name, tuple)
+    if hasattr(topicName, "msgDataSpec"): 
+        topicName = topicName._topicNameStr
+    if py2and3.isstring(topicName): 
+        topicTuple = tuple(topicName.split('.'))
+    else:
+        topicTuple = tuple(topicName) # assume already tuple of strings
+        
+    if not topicTuple:
+        raise TopicNameError(topicTuple, "Topic name can't be empty!")
+                
+    return topicTuple
+
+

wx/lib/pubsub/core/treeconfig.py

@@ -0,0 +1,21 @@
+"""
+
+:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE_BSD_Simple.txt for details.
+"""
+
+from .notificationmgr import NotificationMgr
+
+
+class TreeConfig:
+    """
+    Each topic tree has its own topic manager and configuration,
+    such as notification and exception handling.
+    """
+
+    def __init__(self, notificationHandler=None, listenerExcHandler=None):
+        self.notificationMgr = NotificationMgr(notificationHandler)
+        self.listenerExcHandler = listenerExcHandler
+        self.raiseOnTopicUnspecified = False
+
+

wx/lib/pubsub/core/validatedefnargs.py

@@ -0,0 +1,29 @@
+"""
+Some topic definition validation functions. 
+
+:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE_BSD_Simple.txt for details.
+"""
+
+from .topicexc import MessageDataSpecError
+
+
+def verifyArgsDifferent(allArgs, allParentArgs, topicName):
+    """Verify that allArgs does not contain any of allParentArgs. Raise
+    MessageDataSpecError if fail. """
+    extra = set(allArgs).intersection(allParentArgs)
+    if extra:
+        msg = 'Args %%s already used in parent of "%s"' % topicName
+        raise MessageDataSpecError( msg, tuple(extra) )
+
+
+def verifySubset(all, sub, topicName, extraMsg=''):
+    """Verify that sub is a subset of all for topicName. Raise
+    MessageDataSpecError if fail. """
+    notInAll = set(sub).difference(all)
+    if notInAll:
+        args = ','.join(all)
+        msg = 'Params [%s] missing inherited [%%s] for topic "%s"%s' % (args, topicName, extraMsg)
+        raise MessageDataSpecError(msg, tuple(notInAll) )
+
+

wx/lib/pubsub/core/weakmethod.py

@@ -0,0 +1,102 @@
+"""
+This module provides a basic "weak method" implementation, WeakMethod. It uses
+weakref.WeakRef which, used on its own, produces weak methods that are dead on
+creation, not very useful. Use the getWeakRef(object) module function to create the
+proper type of weak reference (weakref.WeakRef or WeakMethod) for given object.
+
+:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE_BSD_Simple.txt for details.
+
+"""
+
+# for function and method parameter counting:
+from inspect import ismethod
+# for weakly bound methods:
+from types import MethodType
+from weakref import ref as WeakRef
+
+
+class WeakMethod:
+    """Represent a weak bound method, i.e. a method which doesn't keep alive the
+    object that it is bound to. """
+
+    def __init__(self, method, notifyDead = None):
+        """The method must be bound. notifyDead will be called when
+        object that method is bound to dies. """
+        assert ismethod(method)
+        if method.__self__ is None:
+            raise ValueError('Unbound methods cannot be weak-referenced.')
+
+        self.notifyDead = None
+        if notifyDead is None:
+            self.objRef = WeakRef(method.__self__)
+        else:
+            self.notifyDead = notifyDead
+            self.objRef = WeakRef(method.__self__, self.__onNotifyDeadObj)
+
+        self.fun = method.__func__
+        self.cls = method.__self__.__class__
+
+    def __onNotifyDeadObj(self, ref):
+        if self.notifyDead:
+            try:
+                self.notifyDead(self)
+            except Exception:
+                import traceback
+                traceback.print_exc()
+
+    def __call__(self):
+        """Returns a MethodType if object for method still alive.
+        Otherwise return None. Note that MethodType causes a
+        strong reference to object to be created, so shouldn't save
+        the return value of this call. Note also that this __call__
+        is required only for compatibility with WeakRef.ref(), otherwise
+        there would be more efficient ways of providing this functionality."""
+        if self.objRef() is None:
+            return None
+        else:
+            return MethodType(self.fun, self.objRef())
+
+    def __eq__(self, method2):
+        """Two WeakMethod objects compare equal if they refer to the same method
+        of the same instance. Thanks to Josiah Carlson for patch and clarifications
+        on how dict uses eq/cmp and hashing. """
+        if not isinstance(method2, WeakMethod):
+            return False
+
+        return (    self.fun      is method2.fun
+                and self.objRef() is method2.objRef()
+                and self.objRef() is not None )
+
+    def __hash__(self):
+        """Hash is an optimization for dict searches, it need not
+        return different numbers for every different object. Some objects
+        are not hashable (eg objects of classes derived from dict) so no
+        hash(objRef()) in there, and hash(self.cls) would only be useful
+        in the rare case where instance method was rebound. """
+        return hash(self.fun)
+
+    def __repr__(self):
+        dead = ''
+        if self.objRef() is None:
+            dead = '; DEAD'
+        obj = '<%s at %s%s>' % (self.__class__, id(self), dead)
+        return obj
+
+    def refs(self, weakRef):
+        """Return true if we are storing same object referred to by weakRef."""
+        return self.objRef == weakRef
+
+
+def getWeakRef(obj, notifyDead=None):
+    """Get a weak reference to obj. If obj is a bound method, a WeakMethod
+    object, that behaves like a WeakRef, is returned; if it is
+    anything else a WeakRef is returned. If obj is an unbound method,
+    a ValueError will be raised."""
+    if ismethod(obj):
+        createRef = WeakMethod
+    else:
+        createRef = WeakRef
+
+    return createRef(obj, notifyDead)
+

wx/lib/pubsub/policies.py

@@ -0,0 +1,24 @@
+"""
+Aggregates policies for pubsub. Mainly, related to messaging protocol. 
+
+:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE_BSD_Simple.txt for details.
+"""
+
+msgProtocolTransStage = None
+
+msgDataProtocol    = 'kwargs'
+msgDataArgName     = None
+senderKwargNameAny = False
+
+
+def setMsgDataArgName(stage, listenerArgName, senderArgNameAny=False):
+    global senderKwargNameAny
+    global msgDataArgName
+    global msgProtocolTransStage
+    senderKwargNameAny = senderArgNameAny
+    msgDataArgName = listenerArgName
+    msgProtocolTransStage = stage
+    #print `policies.msgProtocolTransStage`, `policies.msgDataProtocol`, \
+    #      `policies.senderKwargNameAny`, `policies.msgDataArgName`
+    #print 'override "arg1" protocol arg name:', argName

wx/lib/pubsub/pub.py

@@ -0,0 +1,199 @@
+"""
+This is the main entry-point to pubsub's core functionality. The :mod:`~pubsub.pub` 
+module supports:
+
+* messaging: publishing and receiving messages of a given topic
+* tracing: tracing pubsub activity in an application
+* trapping exceptions: dealing with "badly behaved" listeners (ie that leak exceptions)
+* specificatio of topic tree: defining (or just documenting) the topic tree of an 
+  application; message data specification (MDS)
+
+The recommended usage is ::
+
+    from pubsub import pub
+    
+    // use pub functions:
+    pub.sendMessage(...)
+    
+Note that this module creates a "default" instance of 
+pubsub.core.Publisher and binds several local functions to some of its methods
+and those of the pubsub.core.TopicManager instance that it contains. However, an
+application may create as many independent instances of Publisher as
+required (for instance, one in each thread; with a custom queue to mediate 
+message transfer between threads).
+"""
+
+"""
+:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE_BSD_Simple.txt for details.
+"""
+
+VERSION_API = 3  #: major API version
+
+VERSION_SVN = "$Rev: 243 $".split()[1]  # DO NOT CHANGE: automatically updated by VCS
+
+from .core import (
+    Publisher as _Publisher,
+
+    AUTO_TOPIC,
+
+    ListenerMismatchError,
+    TopicDefnError, 
+
+    IListenerExcHandler,
+    ExcHandlerError,
+
+    SenderMissingReqdMsgDataError, 
+    SenderUnknownMsgDataError, 
+    
+    TopicDefnError,
+    TopicNameError,
+    UnrecognizedSourceFormatError,
+    
+    ALL_TOPICS,
+    
+    MessageDataSpecError, 
+    exportTopicTreeSpec,
+    TOPIC_TREE_FROM_MODULE,
+    TOPIC_TREE_FROM_STRING,
+    TOPIC_TREE_FROM_CLASS, 
+
+    TopicTreeTraverser,
+    
+    INotificationHandler,
+)
+
+__all__ = [
+    # listener stuff:
+    'subscribe', 
+    'unsubscribe', 
+    'unsubAll',
+    'isSubscribed', 
+
+    'isValid', 
+    'validate',
+    'ListenerMismatchError',
+    'AUTO_TOPIC',
+
+    'IListenerExcHandler',
+    'getListenerExcHandler', 
+    'setListenerExcHandler',
+    'ExcHandlerError',
+    
+    # topic stuff:
+    
+    'ALL_TOPICS', 
+    'topicTreeRoot', 
+    'topicsMap', 
+    
+    'getDefaultTopicMgr', 
+
+    # topioc defn provider stuff
+    
+    'addTopicDefnProvider', 
+    'clearTopicDefnProviders',
+    'getNumTopicDefnProviders',
+    'TOPIC_TREE_FROM_MODULE',
+    'TOPIC_TREE_FROM_CLASS', 
+    'TOPIC_TREE_FROM_STRING',
+    'exportTopicTreeSpec', 
+    'instantiateAllDefinedTopics'
+
+    'TopicDefnError', 
+    'TopicNameError', 
+    
+    'setTopicUnspecifiedFatal',
+
+    # publisher stuff:
+
+    'sendMessage', 
+    'SenderMissingReqdMsgDataError', 
+    'SenderUnknownMsgDataError',
+
+    # misc:
+    
+    'addNotificationHandler', 
+    'setNotificationFlags', 
+    'getNotificationFlags',
+    'clearNotificationHandlers',
+    
+    'TopicTreeTraverser',
+
+]
+
+
+# --------- Publisher singleton and bound methods ------------------------------------
+
+_publisher = _Publisher()
+
+subscribe   = _publisher.subscribe
+unsubscribe = _publisher.unsubscribe
+unsubAll    = _publisher.unsubAll
+sendMessage = _publisher.sendMessage
+
+getListenerExcHandler     = _publisher.getListenerExcHandler
+setListenerExcHandler     = _publisher.setListenerExcHandler
+
+addNotificationHandler    = _publisher.addNotificationHandler
+clearNotificationHandlers = _publisher.clearNotificationHandlers
+setNotificationFlags      = _publisher.setNotificationFlags
+getNotificationFlags      = _publisher.getNotificationFlags
+
+setTopicUnspecifiedFatal  = _publisher.setTopicUnspecifiedFatal
+
+getMsgProtocol            = _publisher.getMsgProtocol
+
+def getDefaultPublisher():
+    """Get the Publisher instance created by default when this module
+    is imported. See the module doc for details about this instance."""
+    return _publisher
+
+
+# ---------- default TopicManager instance and bound methods ------------------------
+
+_topicMgr = _publisher.getTopicMgr()
+
+topicTreeRoot = _topicMgr.getRootAllTopics() 
+topicsMap     = _topicMgr._topicsMap 
+
+
+def isValid(listener, topicName):
+    """Return true only if listener can subscribe to messages of given topic."""
+    return _topicMgr.getTopic(topicName).isValid(listener)
+
+
+def validate(listener, topicName):
+    """Checks if listener can subscribe to topicName. If not, raises
+    ListenerMismatchError, otherwise just returns."""
+    _topicMgr.getTopic(topicName).validate(listener)
+
+
+def isSubscribed(listener, topicName):
+    """Returns true if listener has subscribed to topicName, false otherwise.
+    WARNING: a false return is not a guarantee that listener won't get
+    messages of topicName: it could receive messages of a subtopic of
+    topicName. """
+    return _topicMgr.getTopic(topicName).hasListener(listener)
+
+
+def getDefaultTopicMgr():
+    """Get the TopicManager instance created by default when this 
+    module is imported. This function is a shortcut for 
+    ``pub.getDefaultPublisher().getTopicMgr()``."""
+    return _topicMgr
+
+
+addTopicDefnProvider     = _topicMgr.addDefnProvider
+clearTopicDefnProviders  = _topicMgr.clearDefnProviders
+getNumTopicDefnProviders = _topicMgr.getNumDefnProviders
+
+def instantiateAllDefinedTopics(provider):
+    """Loop over all topics of given provider and "instantiate" each topic, thus 
+    forcing a parse of the topics documentation, message data specification (MDS), 
+    comparison with parent MDS, and MDS documentation. Without this function call, 
+    an error among any of those characteristics will manifest only if the a 
+    listener is registered on it. """
+    for topicName in provider:
+        _topicMgr.getOrCreateTopic(topicName)
+        
+#---------------------------------------------------------------------------