Stack Implemented as a LinkedList in Python

In preparation for interviews, I am attempting to write a Stack as a LinkedList in python. This is what I came up with:

 class Stack:  
   class Element:  
     def __init__(self, data=None, next=None):  
       self.next = next  
       self.data = data  
         
     def __repr__(self):  
       return str(self.data)  
       
   def __init__(self):  
     self.head = self.Element()  
       
   def push(self, data):  
     newHead = self.Element(data=data, next=self.head)  
     self.head = newHead  
     
   def pop(self):  
     head = self.head  
     self.head = head.next  
     return head  
     
   def delete(self):  
     self.head = None  

If anyone sees anything wrong, please let me know!

Latex - compile from PS -> PDF

I'm a total n00b (sp?) when it comes to Latex. Today, I had to compile a latex file with .eps files in it. When hitting the Typeset button in Emacs, there was an error: "Latex Error: Unknown graphics extension: .eps." What? Google searches were vague, difficult to interpret because I'm a n00b. I finally found some documentation that mentioned converting directly from Latex => PDF won't work when using EPS images. Instead, you need to convert from Latex => PS => PDF. OK, how do I do this??

This website offered the solution I was looking for: http://www.maths.ox.ac.uk/help/faqs/latex/conversions. Basically, from the command line, you can use the following commands when in the directory that your .tex file is in:

latex [texfile].tex
dvips -o file.ps [texfile][.dvi]
ps2pdf file.ps file.pdf
open file.pdf

Substitute the correct file names in the commands above with your own! The last line will open your new latex pdf file.

Happy latexing!

Matplotib - adding patterns to bars

Matplotlib is an excellent library for building graphs in python. I've used it before to create graphs for school and my post on jacks or better. Today, I needed to create a bar chart for black and white printing, so the standard color scheme wouldn't work! I tried to find documentation online for how to do this, and found nothing. Finally, I figured it out. You can use the hatch property in the optional kwargs arguments to create the patterns. For example, the code looks something like this

1:  kwargs = {'hatch':'.'}
2:  rects = ax.bar(left, height, width, color='w', **kwargs)

This creates a bar with dots in the center. Here's an example:


Here's all of the code:

1:  import numpy as np  
2:  import matplotlib.pyplot as plt  
3:    
4:  N = 2  
5:  ind = np.arange(N) # the x locations for the groups  
6:  offset = 0.05  
7:  width = 0.24    # the width of the bars  
8:    
9:  fig = plt.figure()  
10:  ax = fig.add_subplot(111)  
11:    
12:  baseline = [7.64, 3.89]  
13:  baselineStd = [0.59, 0.06]  
14:  kwargs = {"hatch":'x'}  
15:  rects1 = ax.bar(offset+ind, baseline, width, color='w', ecolor='k', yerr=baselineStd, **kwargs)  
16:    
17:  leaf = [7.06, 3.69]  
18:  leafStd = [0.67, 0.12]  
19:  kwargs = {"hatch":'.'}  
20:  rects2 = ax.bar(offset+ind+width, leaf, width, color='w', ecolor='k', yerr=leafStd, **kwargs)  
21:    
22:  ultrapeer = [5.76, 3.25]  
23:  ultrapeerStd = [0.32, 0.19]  
24:  kwargs = {"hatch":'/'}  
25:  rects3 = ax.bar(offset+ind+width+width, ultrapeer, width, color='w', ecolor='k', yerr=ultrapeerStd, **kwargs)  
26:    
27:  # add labels  
28:  ax.set_ylabel('Estimated Lifetime (hours)')  
29:  ax.set_xticks(offset+ind+width+width/2)  
30:  ax.set_xticklabels( ('Inactive Mac2', 'Active Mac2') )  
31:    
32:  ax.legend( (rects1[0], rects2[0], rects3[0]), ('Baseline', 'Leaf', 'Ultrapeer') )  
33:    
34:  plt.show()  

Lazy Load - a jQuery plugin

While visiting Mashable today, I noticed that the images on the page were being loaded as I scrolled down. Very cool! Allows for a very quick page load time. I did some research and found that this can be accomplished using Lazy Load, a plugin for jQuery: http://www.appelsiini.net/projects/lazyload. I haven't tried it myself, so I can't really attest to it's functionality, but I highly recommend this plugin for anyone creating a web page with heavy image content.

Photo-bot

My latest project for school involved creating a photo editing and sharing website using Google App Engine. I was excited about the opportunity because (a) I love creating web apps and (b) I was interested in learning app engine. I was pretty happy with the results of my assignment, so I thought I'd share my site with everyone: http://photo-bot.appspot.com/.

There was one pretty tricky use case I had to handle for the assignment. App Engine limits the size of Blobs saved in their datastore to 1MB. However, I had to allow users to upload photos greater than 1MB. Before saving to the datastore, the images needed to be resized. Simply keeping the image data in memory and calling images.resize() is not good enough, since the call to images.resize() actually saves the image data in the datastore, which throws an exception when the image is too large.

To solve the problem, I used blobstore. Blobstore allows files up to 10MB in size. The images could then retrieved from the blobstore, resized and saved to the datastore. The blobstore entry would then be deleted, since saving to the blobstore costs $$. :)

Of course, this makes the code more complex. And, of course, documentation on the App Engine google page is quite limited! Luckily, I found some excellent code posted by Benjamin Pearson. Thanks to Benjamin for posting this code, it helped immensely in trying to solve the problem! I thought I'd post my code, too, in order to get more information out there on the topic. Here's what my basic class looked like:

1:  class AddPhotos(blobstore_handlers.BlobstoreUploadHandler, GenericHandler):
2:    def get(self):
3:      uploadUrl = blobstore.create_upload_url('/addPhotos')  
4:      self.template_values['uploadUrl']=uploadUrl
5:      self.setTemplate('templates/addPhotos.html')
6:
7:    def post(self):
8:      upload_files = self.get_uploads()  
9:      blob_info = upload_files[0]  
10:      blob_key = blob_info.key()  
11:      photo = main.Photo(image=db.Blob(self.getImage(maxImageDimension, maxImageDimension, blob_key)), 
12:               dateAdded=datetime.today(),
13:               dateModified=datetime.today(),
14:               thumb=db.Blob(self.getImage(maxThumbWidthDimension, maxThumbHeightDimension, blob_key))
15:               )
16:      photo.put()
17:      blobstore.get(blob_key).delete() #delete image after use  
18:      self.redirect('/')
19:
20:    def getImage(self, maxWidthDimension, maxHeightDimension, blob_key):
21:      img = images.Image(blob_key=str(blob_key))   
22:      img.resize(width=maxWidthDimension, height=maxHeightDimension)
23:      image = img.execute_transforms(output_encoding=images.PNG) 
24:      return image

First, a disclaimer about the code: this is the most basic form of my code. I didn't include error checking, among other things. I only wanted to cover the basics, since even the basics can be tricky.

That being said, I want to point out the important pieces of the code (in bold). At line 1, I made my class a subclass of BlobstoreUploadHandler, and not the typical request handler. This is required when uploading to the blobstore.

Next, I created an upload URL, passing it a path (line 3). App engine redirects to a post call on the path that you pass. This path should be in your call to the WSGIApplication constructor:

1:  application = webapp.WSGIApplication([
2:                       #Main Page
3:                       ('/', handlers.MainHandler),
4:                  
5:                       #Add photos
6:                       ('/addPhotos', handlers.AddPhotos),  
7:                       ],
8:                       debug=True)
9:  util.run_wsgi_app(application)

In my case, app engine redirects a post call on /addPhotos, which is handled by the AddPhotos class.

Now we have to handle the post and retrieve the blobstore upload. Behind the scenes, Google App engine uploads the file to the blobstore, and allows us to get access to the blob via the key. This is done in lines 8-10. First, the uploaded files are retrieved by calling self.get_uploads(). Next the blob_info is obtained for the first file uploaded. Finally, the key is retrieved. (Note: this could probably be done in one line!)

The key gives access to the image data. In line 21, you can see that a new Image object is created by passing the blob key to the constructor. The image object can be used to resize or transform the uploaded photo using any of the Image functions. After performing the transformations, make sure to execute the transformations by calling execute_transformations() on the Image.

Once the image has been altered, you can save the image to the database as a blob (line 11). Pass the result of the execute_transformations() call to the db.Blob constructor and, as long as your image is now less than 1MB in size, you can save this blob to the datastore!

Finally, delete the blobstore object, since there is no need for it anymore (line 17).

One thing I should mention before I end: you need a billing account with Google before you can use the Blobstore in production (locally it will work fine). However, as long as your blobstore data usage is small, you won't get charged.

Good luck!