Flask post url не перенаправляет динамическую ссылку

Question

У меня возникают проблемы с получением моей учебной фляги при отображении динамической ссылки в сообщении в блоге. Динамическая ссылка, которую я предполагаю, чтобы получить это http://localhost:8000/blog/hello

, но я получил эту ссылку тарабарщину вместо http://localhost:8000/%3Cbound%20method%20Post.url%20of%20%3C__main__.Post%20object%20at%200x7f04ddd9dd50%3E%3E

import os 
import sys 

import collections 
from flask import Flask, render_template, url_for, abort, request 
from flask.ext.frozen import Freezer 
from werkzeug import cached_property 
from werkzeug.contrib.atom import AtomFeed 
import markdown 
import yaml 
from string import strip 

POSTS_FILE_EXTENSION = '.md' 

class SortedDict(collections.MutableMapping): 
    def __init__(self, items= None, key=None, reverse=False): 
     self._items = {} #python dict 
     self._keys =[] #python list 
     if key: 
      self._key_fn = lambda k: key(self._items[k]) 
     else: 
      self._key_fn = lambda k: self._items[k] 
     self._reverse = reverse 

     if items is not None: 
      self.update(items) 

    #abstract base class 
    def __getitem__(self, key): 
     return self._items[key] 

    def __setitem__(self, key, value): 
     self._items[key]= value 
     if key not in self._keys: 
      self._keys.append(key) 
      self._keys.sort(key= self._key_fn, reverse= self._reverse) 


    def __delitem__(self, key): 
     self._items.pop(key) 
     self._keys.remove(key) 

    def __len__(self): 
     return len(self._keys) 

    def __iter__(self): 
     for key in self._keys: 
      yield key 
    def __repr__(self): 
     return '%s(%s)' % (self.__class__.__name__, self._items) 

class Blog(object): 
    def __init__(self, app, root_dir='',file_ext=POSTS_FILE_EXTENSION): 
     self.root_dir = root_dir 
     self.file_ext = file_ext 
     self._app =app #_ for private and internal 
     self._cache = SortedDict(key = lambda p: p.date, reverse= True) 
     self._initialize_cache() 

    @property 
    def posts(self): 
     return self._cache.values() 

    def get_post_or_404(self, path): 
     """ Returns the Post object for the given path or raises a NotFound exception""" 
     try: 
      return self._cache[path] 
     except KeyError: 
      abort(404) 

    def _initialize_cache(self): 
     """walks the root directory and adds all posts to the cache """ 
     for (root, dirpaths, filepaths) in os.walk(self.root_dir): 
      for filepath in filepaths: 
       filename, ext = os.path.splitext(filepath) 
       if ext == self.file_ext: 
        path = os.path.join(root, filepath).replace(self.root_dir,'') 
        post = Post(path, root_dir = self.root_dir) 
        self._cache[post.urlpath] = post 


class Post(object): 
    def __init__(self, path, root_dir=''): 
     self.urlpath = os.path.splitext(path.strip('/'))[0] 
     self.filepath = os.path.join(root_dir, path.strip('/')) 
     self._initialize_metadata() 

    @cached_property 
    def html(self): 
     with open(self.filepath, 'r') as fin: 
      content = fin.read().split('\n\n',1)[1].strip() 
     return markdown.markdown(content) 


    def url(self,_external= False): 
     return url_for('post',path=self.urlpath, _external=_external) 

    def _initialize_metadata(self): 
     content = '' 
     with open(self.filepath, 'r') as fin: 
      for line in fin: 
       if not line.strip(): 
        break 
       content += line 
     self.__dict__.update(yaml.load(content)) 

app = Flask(__name__) 
blog = Blog(app, root_dir= 'posts') 
freezer = Freezer(app) 

@app.template_filter('date') 
def format_date(value, format = '%B %d, %Y'): 
    from datetime import date, datetime, time 
    return value.strftime(format) 



@app.route('/') 
def index(): 
    return render_template('index.html', posts= blog.posts) 


@app.route('/blog/<path:path>/') 
def post(path): 
    #import ipdb; ipdb.set_trace() 
    #import pdb; pdb.set_trace() 
    #path = os.path.join('posts', path + POSTS_FILE_EXTENSION) 
    #post = Post(path) 
    post = blog.get_post_or_404(path) 
    #post = Post(path + POSTS_FILE_EXTENSION, root_dir = 'posts') 
    return render_template('post.html', post=post) 

@app.route('/feed.atom') 
def feed(): 
    feed = AtomFeed('Recent Articles', 
        feed_url=request.url, 
        url=request.url_root) 
    posts = blog.posts[:10] 
    title = lambda p: '%s: %s' %(p.title, p.subtitle) if hasattr(p, 'subtitle') else p.title 
    for post in posts: 
     feed.add(title(post), 
       unicode(post.html), 
       content_type='html', 
       author='Mancube', 
       url=post.url(_external= True), 
       updated=post.date, 
       published=post.date) 
    return feed.get_response() 


if __name__ == '__main__': 
    if len(sys.argv) > 1 and sys.argv[1] =='build': 
     freezer.freeze() 
    else: 
     post_files = [post.filepath for post in blog.posts] 
     app.run(port=8000, debug=True, extra_files = post_files) 

Мой index.html:

{% extends "base.html" %} 
{% block head %} 
    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='css/index.css') }}"> 
{% endblock head %} 

{% block content %} 
    <div id="header"> 
     <h1>My awesome blog</h1> 
    </div> 

    <div id="posts"> 
    {% for post in posts %} 
     <div class="post"> 
     <span class="post-date">{{ post.date|date }}</span> 
     <a href="{{ post.url }}" class="post-title"> 
      {{ post.title}}{% if post.subtitle %}: {{ post.subtitle }} {% endif %} 
     </a> 
     </div> 
    {% endfor %} 

    </div> 
{% endblock content %} 

Я очень новой для колба , Я надеюсь, что кто-то может помочь мне в этом.

Answer 1

href="{{ post.url }}" 

Это функция, которую вы должны называть ее «post.url()».