wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/lib/progressindicator.py

@@ -0,0 +1,151 @@
+#----------------------------------------------------------------------
+# Name:        wx.lib.progressindicator
+# Purpose:
+#
+# Author:      Robin Dunn
+#
+# Created:     22-Oct-2009
+# Copyright:   (c) 2009-2020 by Total Control Software
+# Licence:     wxWindows license
+#----------------------------------------------------------------------
+
+"""
+A simple gauge with a label that is suitable for use in places like a
+status bar.  It can be used in either an automatic indeterminant
+(pulse) mode or in determinante mode where the programmer will need to
+update the position of the progress bar.  The indicator can be set to
+hide itself when it is not active.
+"""
+
+import wx
+
+#----------------------------------------------------------------------
+# Supported Styles
+
+PI_PULSEMODE = 1
+PI_HIDEINACTIVE = 2
+
+#----------------------------------------------------------------------
+
+class ProgressIndicator(wx.Panel):
+    def __init__(self, *args, **kw):
+        wx.Panel.__init__(self, *args, **kw)
+
+        self.label = wx.StaticText(self)
+        self.gauge = wx.Gauge(self, range=100,
+                              style=wx.GA_HORIZONTAL|wx.GA_SMOOTH)
+
+        self._startCount = 0
+        self.Sizer = wx.BoxSizer(wx.HORIZONTAL)
+        self.Sizer.Add(self.label, 0, wx.ALIGN_CENTER_VERTICAL)
+        self.Sizer.Add(self.gauge, 1, wx.EXPAND)
+
+        size = wx.DefaultSize
+        if 'size' in kw:
+            size = kw['size']
+        elif len(args) >= 4:
+            size=args[3] # parent, id, pos, size, style, name
+
+        self.SetInitialSize(size)
+
+        if self.HasFlag(PI_PULSEMODE):
+            self.timer = wx.Timer(self)
+            self.Bind(wx.EVT_TIMER, self.onTimer)
+        if self.HasFlag(PI_HIDEINACTIVE):
+            self.Hide()
+
+
+    def __del__(self):
+        if hasattr(self, 'timer'):
+            self.timer.Stop()
+            del self.timer
+
+
+    def Start(self, label=None):
+        """
+        Show (if necessary) and begin displaying progress
+        """
+        self._startCount += 1
+        if label is not None:
+            self.SetLabel(label)
+        if self.HasFlag(PI_HIDEINACTIVE):
+            self.Show()
+            self.Layout()
+        if self.HasFlag(PI_PULSEMODE):
+            self.gauge.Pulse()
+            self.timer.Start(250)
+        else:
+            self.gauge.SetValue(0)
+
+
+    def Stop(self, clearLabel=False):
+        """
+        Stop showing progress
+        """
+        # Make sure Stop is called as many times as Start was. Only really
+        # stop when the count reaches zero.
+        if self._startCount == 0:
+            return  # should be already stopped...
+        self._startCount -= 1
+        if self._startCount:
+            return # there's still more starts than stops...
+
+        if self.HasFlag(PI_HIDEINACTIVE):
+            self.Hide()
+
+        if self.HasFlag(PI_PULSEMODE):
+            self.timer.Stop()
+
+        if clearLabel:
+            self.label.SetLabel("")
+
+
+    def SetLabel(self, text):
+        """
+        Set the text displayed in the label.
+        """
+        self.label.SetLabel(text)
+        self.Layout()
+
+
+    def SetValue(self, value, label=None):
+        """
+        For determinante mode (non-pulse) update the progress indicator to the
+        given value. For example, if the job is 45% done then pass 45 to this
+        method (as long as the range is still set to 100.)
+        """
+        if label is not None:
+            self.SetLabel(label)
+        self.gauge.SetValue(value)
+
+
+    def SetRange(self, maxval):
+        """
+        For determinante mode (non-pulse) set the max value that the gauge can
+        be set to. Defaults to 100.
+        """
+        self.gauge.SetRange(maxval)
+
+
+    def onTimer(self, evt):
+        self.gauge.Pulse()
+
+
+#----------------------------------------------------------------------
+
+if __name__ == '__main__':
+    app = wx.App(redirect=False)
+    frm = wx.Frame(None, title="ProgressIndicator")
+    pnl = wx.Panel(frm)
+    pi1 = ProgressIndicator(pnl, pos=(20,20), size=(150,-1),
+                            style=PI_HIDEINACTIVE|PI_PULSEMODE)
+
+    pi2 = ProgressIndicator(pnl, pos=(20,60), size=(150,-1),
+                            style=PI_HIDEINACTIVE)
+
+    import wx.lib.inspection
+    wx.lib.inspection.InspectionTool().Show()
+
+    frm.Show()
+    app.MainLoop()
+

wx/lib/pubsub/LICENSE_BSD_Simple.txt

@@ -0,0 +1,23 @@
+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.
+

wx/lib/pubsub/README_WxPython.txt

@@ -0,0 +1,22 @@
+# this file gets copied to wx/lib/pubsub folder when release to wxPython
+
+For wxPython users:
+
+The code in this wx/lib/pubsub folder is taken verbatim from the PyPubSub
+project on SourceForge.net. Pubsub originated as a wxPython lib, but it is now
+a standalone project on SourceForge. It is included as part of wxPython
+distribution for convenience to wxPython users, but pubsub can also be installed
+standalone (see installation notes at http://pypubsub.sourceforge.net), or you
+can also overwrite the version in this folder with the standalone version or
+put an SVN checkout of pubsub in this folder, etc.
+
+Note that the source distribution on SF.net tends to be updated more often than
+the copy in wx/lib/pubsub. If you wish to install pubsub standalone, there are
+instructions on the Install page of http://pypubsub.sourceforge.net.
+
+There is extensive documentation for pubsub at http://pypubsub.sourceforge.net,
+and some examples are in wx/lib/pubsub/examples. The WxPython wiki also discusses
+usage of pubsub in wxPython.
+
+Oliver Schoenborn
+December 2013

wx/lib/pubsub/RELEASE_NOTES.txt

@@ -0,0 +1,71 @@
+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

wx/lib/pubsub/__init__.py

@@ -0,0 +1,25 @@
+"""
+Pubsub package initialization.
+
+:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE_BSD_Simple.txt for details.
+"""
+
+_PREVIOUS_RELEASE_DATE = "2013-09-15"
+_PREVIOUS_RELEASE_VER = "3.2.1b"
+
+__version__ = "3.3.0"
+
+__all__ = [
+    'pub',
+    'utils',
+    'setupkwargs',
+    'setuparg1',
+    '__version__'
+    ]
+
+import wx
+import warnings
+warnings.warn('wx.lib.pubsub has been deprecated, plese migrate your '
+              'code to use pypubsub, available on PyPI.',
+              wx.wxPyDeprecationWarning)

wx/lib/pubsub/core/__init__.py

@@ -0,0 +1,92 @@
+"""
+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 folder, 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 since 2006 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE_BSD_Simple.txt for details.
+
+"""
+    
+
+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))
+
+# 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,
+)

wx/lib/pubsub/core/arg1/__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 "arg1" (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/arg1/listenerimpl.py

@@ -0,0 +1,97 @@
+"""
+: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
+
+
+class Message:
+    """
+    A simple container object for the two components of a topic messages
+    in the pubsub legacy API: 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: '+repr(self.topic)+',  Data: '+repr(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
+        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 ListenerMismatchError(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 ListenerMismatchError(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 ListenerMismatchError(msg, listener, effTopicArgs)
+
+

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

@@ -0,0 +1,40 @@
+"""
+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 since 2006 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE_BSD_Simple.txt for details.
+"""
+
+
+from .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'
+

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

@@ -0,0 +1,34 @@
+"""
+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 since 2006 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE_BSD_Simple.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)

wx/lib/pubsub/core/arg1/topicargspecimpl.py

@@ -0,0 +1,66 @@
+"""
+
+:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE_BSD_Simple.txt for details.
+
+"""
+
+import weakref
+from .topicutils import WeakNone
+
+class SenderMissingReqdMsgDataError(RuntimeError):
+    """
+    Ignore: Not used for this message protocol.
+    """
+    pass
+
+
+class SenderUnknownMsgDataError(RuntimeError):
+    """
+    Ignore: Not used for this message protocol.
+    """
+    pass
+
+
+class ArgsInfo:
+    """
+    Encode the Message Data Specification (MDS) for a given
+    topic. In the arg1 protocol of pubsub, this MDS 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 MDS 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()
+
+

wx/lib/pubsub/core/arg1/topicmgrimpl.py

@@ -0,0 +1,19 @@
+"""
+The root topic of all topics is different based on messaging protocol.
+
+:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
+:license: BSD, see LICENSE_BSD_Simple.txt for details.
+
+"""
+
+from .. import policies
+
+
+def getRootTopicSpec():
+    """If using "arg1" messaging protocol, then root topic has one arg;
+    if policies.msgDataArgName is something, then use it as arg name."""
+    argName = policies.msgDataArgName or 'data'
+    argsDocs = {argName : 'data for message sent'}
+    reqdArgs = (argName,)
+    return argsDocs, reqdArgs
+