This is the generic term I use to describe the most appropriate Python data type for a particular field's data.
It might be a builtin type or it could be an instance of a class someone created. But even in this "simple" case it's important to remember that the string is not necessarily exactly what will be sent to the browser or the database.
This makes widget classes quite tightly coupled to the form fields that they will work with: Widgets render from native types to HTML, but don't convert all the way back to native.
This post will attempt to explain how the data is converted at each stage and offer some advice about creating custom widgets, form fields and model fields.
This article is based on Django 1.3 and assumes the reader has experience creating and using Django forms, models and validation.
This is the term I use to describe Django's extra step between HTML form data and native types.
In any web application user data must be translated from HTML form data to native types and database types, and back again. The "right way" to handle custom types is to extend Django's widgets, form fields and model fields.
However, understanding exactly how these types perform each step of the conversion can be confusing.
It will be escaped and encoded when sent to the browser, and it may be encoded differently when stored in the database.
The native type should be the type that is most convenient for a programmer to work with to manipulate the data, not what is most convenient for the database or web browser. If you find you have HTML entities in your native type, you likely did something wrong.
In the simple case processed data is the value string from an is not allowed to raise any validation errors, so there is a limit to how far conversion to processed data can go.
If the data passed isn't valid one strategy is to return a special value that will be intercepted by the form field so that it can flag the validation error.