I’ve been trying somewhat in vain to debug a REST interface that’s failing when running under GAE. After some searching, I found a way to force the local development server to use an http proxy (such as Charles or Membrane).

Make the following changes in the file:

C:\Program Files\Google\google_appengine\google\appengine\api\urlfetch_stub.py

around line 193:

      
<pre>
try:
    if protocol == 'http':         
        logging.debug("using proxy instead of %s path=%s", host, path)  
        connection = httplib.HTTPConnection("127.0.0.1", 8888)   # host and port of proxy server
        path = "http://%s%s"%(host,path)
        logging.debug("new path is: '%s'", path)
    elif protocol == 'https':
          connection = httplib.HTTPSConnection(host)
    else:
        error_msg = 'Redirect specified invalid protocol: "%s"' % protocol
        logging.error(error_msg)
        raise apiproxy_errors.ApplicationError( urlfetch_service_pb.URLFetchServiceError.FETCH_ERROR, error_msg) 
</pre>

You may wish to make the same change for Https as well. It would not be too hard to fix it the right way by having it check for the http_proxy environment variable, but I haven’t done that.

Here are the slides and examples from my Code Mash 2.0.1.0 talk:

Restful Interfaces to 3rd-Party Websites with Python (PDF)

examples.tar.gz

I’ve been looking to find a way to resize a font when the window’s size changes. Here is code that will create a font that is close as possible to a given height in pixels without specifying anything about the font width. Osku Salerma posted some code in GitHub that did the trick.

I changed it a bit to make it self-contained. Here’s my modified version of his code to create a wxPython font given a height in pixels:

<pre>
    def createFontFromHeightInPixels(self, heightInPixels, family, style, weight):
        # return a font that's as close to 'heightInPixels' as possible without being larger
        # modified from code at http://github.com/oskusalerma/blyte/blob/master/util.py  
        fontSizeToTest = 6
        bestFontSoFar = wx.Font(fontSizeToTest, family, style, weight, encoding = wx.FONTENCODING_ISO8859_1)
        closestDiffInPixelsSoFar = 1000
        testDc = wx.MemoryDC()
        testDc.SelectObject(wx.EmptyBitmap(512, 32)) 
        while 1:
            testedFont = wx.Font(fontSizeToTest, family, style, weight, encoding = wx.FONTENCODING_ISO8859_1)
            testDc.SetFont(testedFont)
            heightOfTestedFont = testDc.GetTextExtent("_\xC5")[1]
            diff = heightInPixels-heightOfTestedFont
            if diff >= 0:
                if diff < closestDiffInPixelsSoFar:
                    closestDiffInPixelsSoFar = diff
                    bestFontSoFar = testedFont
            else:
                break
            fontSizeToTest += 2
        return bestFontSoFar 
</pre>

It would be used like this assuming the above function is in the window class or one of its superclasses:

<pre>
def __init__(self, *args, **kwds):
    .
    .
    .
    self.Bind(wx.EVT_SIZE, self.OnSize)     

def OnSize(self, event):
        size = event.GetSize()
        currentFont = self.GetFont()
        newFont = self.createFontFromHeightInPixels( (size.height*0.8), 
            currentFont.GetFamily(), currentFont.GetStyle(), currentFont.GetWeight())
        self.label_1.SetFont(newFont)
 </pre>

A very slight tweak to the code posted by John Lee on the wwwsearch mailing list at SourceForge allows mechanize to work on the google app engine. The code I am using, which is almost all his, is:

<pre>
import urllib2
import copy
import mechanize
import mechanize._response

class GAEMechanizeHTTPHandler(mechanize.BaseHandler):

    def __init__(self, gae_http_handler, debuglevel=0):
        self._debuglevel = debuglevel
        self._gae_http_handler = gae_http_handler

    def http_open(self, req):
        return self._gae_http_handler.http_open(req)

def make_gae_handler():
    return urllib2.HTTPHandler()

def make_http_handler():
    gae_handler = make_gae_handler()
    return GAEMechanizeHTTPHandler(gae_handler)

class GAEBrowser(mechanize.Browser):
    handler_classes = copy.copy(mechanize.Browser.handler_classes)
    handler_classes["http"] = make_http_handler 
</pre>

Mechanize is not thoroughly tested, but the above does allow my project’s code to pass its regression tests when running on the GAE.

TimeSpin has a bug in that it reports the same width for GetBestSize when AM/PM is shown and when it is not (24 hour format). This causes an empty space to appear after the control when it is set to display time in 24 hours. I’m not able to fix the bug at this point, but I was able to add a workaround that adjusts the width as needed.

Version 1.4 of the time_spin_and_control distrubution contains the workaround.

I added a workaround for a problem with timectrl.

You’ll want to upgrade to the 1.4 version of the time_spin_and_control distribution if you use limited, min, max, or value parameters in Glade when specifying the control.

Edit – 3/8 – updated to version 1.4

The program I’m working on (ErgMate) requires entry of hours/mins/seconds durations. I just defined input as total number of seconds for the initial prototypes, but the time has come to make it more usable. I was able to create the bridge code necessary to add the wx.lib.masked.TimeCtrl to the wxGlade widget palette by following examples from Alberto Griggio .

The normal TimeCtrl can bind to an external scroll button. The package also includes a new control called TimeSpin. It is based on Andrea Gavana’s FloatSpin control, and provides both a TimeCtrl and scroll button in one control. TimeSpin does not accept the format nor the scrollBar parameters, otherwise it should be a drop-in replacement for TimeCtrl. Let me know if I missed something important in the interface.

There is (at least!) one minor problem with TimeSpin: It seems to report too large a width – its bounding box is actually wider than the displayed control. I’d appreciate anyone with more knowledge of wxPython than I looking into it and sending a patch. For now it’s good enough to get started using.

Both time widgets are added to wxGlade by untarring the time_spin_and_control distribution from within your .wxglade directory. The included README contains more details.

Edit:
1.1 – fixed codegen problem w/value
1.2 – fixed loading problem when presetting a value
1.3 – added workaround for bug in timectrl when using min/max/limited settings

The February Cleveland Area Python Users Group Meeting was held last night. The guys at BitBacker opened their doors and supplied pizza. It was the best meeting in awhile – 3 talks!

Christian Wyglendowski kicked things off with an overview of SimpleParse. He’s used it in applications from an ini file parser to a parser for an online survey processing language. It looks easy to use. Some time ago I wrote a parser for generating Python code from FLTK’s Fluid GUI builder data files using Spark. A great library, but SimpleParse might have been so much easier – it depends if I could have created or found a grammar for the fluid file format.

Matt Wilson spoke on IPython. I’ve been using IPython for some time and realized I wasn’t making full use of it. Until his talk I didn’t realize how much of IPython I was missing (“You only use 10% of your Ipython’s capabilities….”). Never knew it would assign results to _## where ## is the history line number. That alone will save a lot of time. Matt’s Ipython talk notes are online at his website.

Matt also gave a short talk on Twill. Twill is a domain-specific language used to test websites and web applications. The most interesting part of Twill is its extensibility. He demonstrated how one can add automatic checks as Twill encounters each page in your application – checks for tables-within-tables for example. Matt’s notes contain more information.

These talks gave us a lot to take home and think about.

This morning I started getting the following exception when generating code from wxGlade:

<pre>
Traceback (most recent call last):
  File "c:\temp\wxGlade\application.py", line 394, in generate_code
    class_names=class_names)
  File "c:\temp\wxGlade\xml_parse.py", line 503, in __init__
   .
   .
   .
  File "c:\temp\wxGlade\xml_parse.py", line 593, in endElement
    self.code_writer.add_class(obj)
  File "c:\temp\wxGlade\codegen\py_codegen.py", line 640, in add_class
    indentation = prev_src.spaces[code_obj.klass]
KeyError: 'FancyListControl'
</pre>

There was only one mention of a similar problem on the wxGlade mailing list. The solution posted there was to start a new project – not really an option at this stage of development.

So after a little digging, I found a different solution.

The item causing the problem is a fancy subclass of ListControl defined in another module. I had placed a wx.Panel in the sizer slot, and had then changed the class to my fancy ListControl. Is the problem now obvious? This fancy list control is not equivalent to a wx.Panel from wxGlade’s perspective. Removing the panel and instead adding a ListControl with my fancy control as the class name fixed everything up.

So, in summary, use the closest matching wxGlade class (ListControl instead of Panel) when using your own classes.

Doh.

wxGlade has an option for ‘overwrite sources’ in the application dialog:

I normally have it off, but when doing some exploratory testing I enabled it. This morning I was working on my main application and regenerated the code. Guess what? Yes, it overwrote every gui class. Three things led to this:

1. I had assumed the overwrite setting was stored in the .wxg file (it is part of the configuration for a given application.)
2. My main wxsGlade window is sized so that option is not normally visible.
3. The value for ‘overwrite sources’ is actually a global configuration.

So BE CAREFUL with this option. Fortunately, a svn update brought the code back to where it was just a few minutes earlier minus a minor gui change.