An implementation of a custom MarkupField for Django. A MarkupField is in essence a TextField with an associated markup format and MarkItUp! markup editor widget with AJAX preview. The field also caches its rendered value on the assumption that disk space is cheaper than CPU cycles in a web application.
Based on django-markupfield and django-markitup.
Installation
The recommended way to install django-markitup-field is with pip
Install from PyPI with easy_install or pip:
pip install django-markitup-field
or get the in-development version:
pip install django-markitup-field==tip
It is not necessary to add 'markitup_field' to your INSTALLED_APPS, it merely needs to be on your PYTHONPATH.
If you want to use AJAX-based preview, add url(r'^markitup/', include('markitup.urls')) in your root URLconf.
Requirements
django-markitup-field depends on a relatively current version of Django (tested with 1.3-1.4, may work with 1.2 but not guaranteed) and libraries for whichever markup options you wish to include.
Settings
You can define the MARKUP_FILTERS setting, a mapping of strings to callables that ‘render’ a markup type:
import markdown
from docutils.core import publish_parts
def render_rest(markup):
parts = publish_parts(source=markup, writer_name="html4css1")
return parts["fragment"]
MARKUP_FILTERS = (
('markdown', markdown.markdown),
('restructuredtext', render_rest),
)
If you do not define a MARKUP_FILTERS then one is provided with the following markup types available:
- html:
allows HTML, potentially unsafe
- text:
plain text markup, calls urlize and replaces text with linebreaks
- markdown:
default markdown renderer (only if python-markdown is installed)
- restructuredtext:
- textile:
Usage
Using MarkupField is relatively easy, it can be used in any model definition:
from django.db import models
from markitup_field.fields import MarkupField
class Article(models.Model):
title = models.CharField(max_length=100)
slug = models.SlugField(max_length=100)
body = MarkupField()
Article objects can then be created with any markup type defined in MARKUP_FORMATS:
Article.objects.create(title='some article', slug='some-article',
body='*fancy*', body_markup_format='markdown')
You will notice that a field named body_markup_format exists that you did not declare, MarkupField actually creates two extra fields. body_markup_format This field is always named according to the name of the declared MarkupField.
Arguments
MarkupField also takes three optional arguments. Either default_markup_format and markup_format arguments may be specified but not both.
- default_markup_format:
Set a markup_type that the field will default to if one is not specified. It is still possible to edit the markup type attribute and it will appear by default in ModelForms.
- markup_format:
Set markup type that the field will always use, editable=False is set on the hidden field so it is not shown in ModelForms.
- markup_choices:
A replacement list of markup choices to be used in lieu of MARKUP_FORMATS on a per-field basis.
- escape_html:
A flag (False by default) indicating that the input should be regarded as untrusted and as such will be run through Django’s escape filter.
- rendered_field_name:
Name for field with rendered content. If it is set to None, then it named <field_name>_rendered
Examples
MarkupField that will default to using markdown but allow the user a choice:
MarkupField(default_markup_type='markdown')
MarkupField that will use textile and not provide a choice on forms:
MarkupField(markup_type='textile')
MarkupField that will use a custom set of renderers:
CUSTOM_RENDERERS = (
('markdown', markdown.markdown),
('wiki', my_wiki_render_func)
)
MarkupField(markup_choices=CUSTOM_RENDERERS)
Accessing a MarkupField on a model
When accessing an attribute of a model that was declared as a MarkupField a special Markup object is returned. The Markup object has three parameters:
- raw:
The unrendered markup.
- markup_format:
The markup type.
- rendered:
The rendered HTML version of raw, this attribute is read-only.
This object has a __unicode__ method that calls django.utils.safestring.mark_safe on rendered allowing MarkupField objects to appear in templates as their rendered selfs without any template tag or having to access rendered directly.
Assuming the Article model above:
>>> a = Article.objects.all()[0] >>> a.body.raw u'*fancy*' >>> a.body.markup_type u'markdown' >>> a.body.rendered u'<p><em>fancy</em></p>' >>> print unicode(a.body) <p><em>fancy</em></p>
Assignment to a.body is equivalent to assignment to a.body.raw and assignment to a.body_markup_format is equivalent to assignment to a.body.markup_format.
Metadata
Release files for django-markitup-field 1.2.10
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| django-markitup-field-1.2.10.zip | 173.6 kB | Without provenance | Details for django-markitup-field-1.2.10.zip |
Release files / django-markitup-field-1.2.10.zip
| Download URL | django-markitup-field-1.2.10.zip |
|---|---|
| Size | 173.6 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
6face93299180375a3c4512b0831638d7ed8caccb2c2363ee141f66d95b26772
|
|
BLAKE2b-256 checksum How to use checksums |
2b3fbd9b9a1e74fdab96fab42fca106676c72c0e66a674adcab41e0793375df1
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
Security for django-markitup-field 1.2.10
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
No provenance found
None of the files in this release were uploaded with provenance metadata.
A note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.