def render_body(self):
"""
Renders standard template with context
"""
if self.body_template is not None:
body = Template(self.body_template).render(self.get_context())
elif self.template_name is not None:
body = loader.get_template(self.template_name).render(self.get_context())
else:
body = None
try:
from markdownify import markdownify
except ImportError:
pass
else:
html_body = self.render_html_body()
if html_body is not None:
body = markdownify(html_body, convert=ALLOWED_TAGS)
if body is None:
raise MissingBody('The email does not have a body. Either'
' provide a body or template_name or, if you'
' really want to send an email without a'
' body, set the body to an empty string'
' explicitly.')
return body
def get_edit(self, id):
""" Get route for Editing an Item
TODO: Make decorator for "owership" of item
"""
item = Item.query.get_or_404(id)
if current_user.id == item.user_id:
commentForm = self._commentForm(request)
commentForm.text.data = markdownify(item.text)
commentForm.edit.data = True
return render_template('item/item.html',
item = item, form = commentForm, title=item.title, edit=True)
else:
return redirect(url_for('.item', id=id))
#!/usr/bin/env python
# some comment as a example
from markdownify import markdownify
with open('example.html') as f:
lines = ''.join(f.readlines())
md = markdownify(lines)
print md
class MyClass(object):
def __init__(self):
# TODO: write something!
pass
def process(url, start=0, fetch=50):
""" Main processing engine """
pos = start
# End will be updated during each request with incoming data
end = pos + fetch
Console.header("Tumblr Import")
Console.info("Importing data...")
Console.indent()
while pos < end:
Console.info("Requesting %s-%s of %s" % (pos, pos+fetch-1, end))
response = requests.get(url % (pos, fetch))
if response.status_code != 200:
raise Exception("Error during communication with Tumblr: %s" % r.status)
tree = ElementTree.fromstring(response.content)
# This element contains all posts
allPosts = tree.find("posts")
# Update end pointer
end = int(allPosts.get("total"))
# Iterate trough all posts
for post in allPosts:
postType = post.get("type")
postTimeStamp = post.get("unix-timestamp")
postExportDate = str(datetime.datetime.fromtimestamp(int(postTimeStamp)))
postSlug = post.get("slug")
postFormat = post.get("format")
postDateOnly = postExportDate[0:postExportDate.find(" ")]
postFileName = "%s-%s" % (postDateOnly, postSlug)
if postType == "quote":
quoteText = post.find("quote-text").text
quoteComment = post.find("quote-source").text
# Post-process
quoteText = markdownify.markdownify("<blockquote>" + quoteText + "</blockquote>").rstrip("\n").lstrip("\n")
quoteComment = markdownify.markdownify(quoteComment).rstrip("\n")
fileContent = quoteTemplate % (postSlug, postExportDate, quoteText + "\n\n" + quoteComment)
elif postType == "photo":
photoText = post.find("photo-caption").text
try:
photoLinkUrl = post.find("photo-link-url").text
except:
photoLinkUrl = None
photoUrl = post.find("photo-url").text
# Post-process
photoText = markdownify.markdownify(photoText).rstrip("\n")
# Downloading image
photoResponse = requests.get(photoUrl, allow_redirects=True)
if photoResponse.status_code != 200:
Console.error("Unable to load photo. Status: %s; URL: %s", photoResponse.status_code, photoUrl)
continue
# Build extension based on response headers (safer than using file extension)
photoType = photoResponse.headers["content-type"]
if "png" in photoType:
photoExtension = ".png"
elif "jpeg" in photoType or "jpg" in photoType:
photoExtension = ".jpeg"
elif "gif" in photoType:
photoExtension = ".gif"
else:
Console.error("Unknown photo format: %s; Status: %s; URL: %s", photoType, photoResponse.status_code, photoUrl)
continue
# Generating checksum
photoHash = hashlib.sha1(photoResponse.content).hexdigest()
# Generate file name and path from existing data
photoFileName = "%s-%s-%s%s" % (postDateOnly, postSlug, photoHash[0:10], photoExtension)
photoPath = os.path.join(photoFolder, photoFileName)
# Do not repeatly write identical files
if not os.path.exists(photoPath):
photoFile = open(photoPath, "wb")
photoFile.write(photoResponse.content)
photoFile.close()
# Generate basic image tag
photoAsset = '<img src="{{@asset.url %s/%s/%s}}" alt=""/>' % (projectName, photoAssetFolder, photoFileName)
# Wrap with a link when it should be link to an external site
if photoLinkUrl:
photoAsset = '<a href="%s">%s</a>' % (photoLinkUrl, photoAsset)
fileContent = photoTemplate % (postSlug, postExportDate, photoAsset + "\n\n" + photoText)
elif postType == "link":
linkUrl = post.find("link-url").text
try:
linkText = post.find("link-text").text
except:
linkText = linkUrl
# Post-process
if linkText != linkUrl:
linkText = markdownify.markdownify(linkText).rstrip("\n")
fileContent = linkTemplate % (postSlug, postExportDate, "[%s](%s)" % (linkText, linkUrl))
elif postType == "video":
videoCode = post.find("video-source").text
videoText = post.find("video-caption").text
# Post-process
videoText = markdownify.markdownify(videoText).rstrip("\n")
fileContent = videoTemplate % (postSlug, postExportDate, videoCode + "\n\n" + videoText)
elif postType == "regular":
postText = post.find("regular-body").text
try:
postTitle = post.find("regular-title").text
except:
# Ignore posts without title
Console.warn("Ignoring post without title!")
continue
postText = markdownify.markdownify(postText).rstrip("\n")
fileContent = regularTemplate % (postSlug, postExportDate, postTitle, postText)
else:
Console.warn("Unknown POST-TYPE: %s" % postType)
print(ElementTree.dump(post))
continue
# Write post file
fileHandle = open(os.path.join(postFolder, postDateOnly + "-" + postType + "-" + postSlug + ".markdown"), "w")
fileHandle.write(fileContent)
fileHandle.close()
# Update for next requests
pos = pos + fetch
Console.outdent()
Console.info("Successfully imported")
