This must obviously be limited, because the abuse potential is very high. Therefore you can not call all possible Internet services. You can retrieve only “web pages” or everything that a Web server is offering on port 80 or 443.

The module urlfetch implements it. A simple usage is:

response = urlfetch.fetch(url)
content = response.content

If everything goes well, this is enough. So far, this is very convienent. But in most real world scenarios, you need to handle all kind of error conditions. Like in this skeleton:

    try:
        response = urlfetch.fetch(jadurl)
        if response.status_code == 200:
            self.xxheaders = response.headers
            self.xxcontent = response.content
            self.xxFetched = True
        elif response.status_code == 404:
            self.errortext = "File not found"
            self.xxcontent = "not found"
        else:
            self.errortext = "Bad Response Code"
            self.xxcontent = response.status_code
    except InvalidURLError:
        self.errortext = "Invalid URL"
    except DownloadError:
        self.errortext = "Error downloading file"
    except ResponseTooLargeError:
        self.errortext = "File to large"

HTTP-Headers

You can also access to the HTTP headers. For example, if you want to access the mime type:

response.headers['content-type']

In my particular use case I am also interested whether a header is sent twice. It seems that you can not get this information.

SSL

You can also access SSL-protected pages with “https: / / . Unfortunately, according to the documentation as of version 1.1, the certificate is not checked. This means, the increased security is not there. This restricts the possible application range.

It was just too easy. If you have a HTML input field of type “file” with the name “Uploadfile”, you can access the uploaded data like this:

filecontent = self.request.get ( 'Uploadfile')

Then the file content is then stored in the variable “filecontent”. If it happens to be a text file, You can process it like a normal string.

For many applications this is and sufficient and very convenient. A few questions are still open for me:

• How to get the original filename?
• If the uploaded file is very big, how can I block further processing as early as possible?

$ dev_appserver.py helloworld

In the directory there must be a configuration file in the format Yaml. This file matches URLs to Python files or to images, etc . If the file does not exist, or it does not contain the required information, an exception is thrown.

Some files will be automatically created, and you can forget them easily:
a configuration file of the SDK in your userdir in file “.appcfg_nag” and a data store (practically the database) in userdir \ temp \ dev_appserver.datastore

Included is a small framework called WebApp.
It separates the Python code from HTML code. There is a template engine with Django-compatible syntax.
I had a problem with the templates, the XML header ()
at the beginning caused my browser not not display the result.

The template language itself uses curly brackets. This is quite compact, unfortunately, the template can be quickly leed to degenerated HTML code, you can non verify the template itself in the browser.

The Web application uses neither the otherwise ubiquitous SQL databases nor the file system to save data. Instead there is a special storage. Ver nice is: you can simply inherit a class from “db.Model”, and you can read and write complete objects to the data store. You do not take care of the instance variables, and you also do not declare any database tables. An SQL-like query language is also available, but apparently this is more “syntactic sugar” than real SQL.