In this article, we will learn about template in flask Let’s start!!<\/p>\n
Templates are scripts that include stand ins for data streams in addition to static data. To create the finished document, a theme is presented with the required data. To render templates, Flask makes use of the Jinja template library. You will utilize templates in your application to render HTML that the user’s browser will see. Jinja is set up in Flask to automatically escape any data rendered in HTML layouts.<\/p>\n
Flask is a compact Py web platform that provides helpful tools and functionalities for developing web applications. A back-end web framework built on the programming language Python is called Flask. In essence, it enables the development of web applications using Pythonic syntax and ideas. We may incorporate Libraries and services into our web applications using Flask. We can put up a webserver using Flask to load some simple HTML templates and the Jinja2 templating syntax. We’ll look at how to render HTML layouts in Flask in this tutorial.<\/p>\n
To render HTML templates in Flask, you can employ the Jinja templating language. A file that contains both static and dynamic content is known as a template. With Jinja, you may answer to user requests with HTML templates that contain numerous capabilities not found in ordinary HTML, such as parameters, if clauses, for cycles, filtering, and theme inheritance. Examples of such requests might be for an index page or a login page. You can effectively create simple-to-maintain HTML pages thanks to these capabilities. To combat Cross-Site Scripting (XSS) threats, Jinja now automatically escapes HTML.<\/p>\n
The result of a procedure that is linked to a specific URL may be returned as HTML. For instance, the hello() method inside the accompanying script will render “Hello World” with an associated h1> tag.<\/p>\n
from flask import Flask\r\n\r\napp = Flask(__name__)\r\n\r\n@app.route('\/')\r\ndef index():\r\n return '<html><body><h2>Welcome to my Flask app!<\/h2><\/body><\/html>'\r\n\r\nif __name__ == '__main__':\r\n app.run(debug=True)\r\n<\/pre>\nOutput:<\/strong><\/p>\nWelcome to my Flask app!<\/p>\n
However, it can be difficult to generate Html page from Python code, especially when changeable information and other Python language features such predicate or loops are required. This would necessitate repeated HTML escaping.<\/p>\n
Here, one can benefit from Flask’s foundational Jinja2 template engine. The render template() function allows an HTML file to be rendered instead of hardcoded HTML being returned.<\/p>\n
from flask import Flask, render_template\r\n\r\napp = Flask(__name__)\r\n\r\n@app.route('\/')\r\ndef demo():\r\n return render_template('HiWorld.html')\r\n\r\nif __name__ == '__main__':\r\n app.run(debug=True)\r\n<\/pre>\nTo show the output of the code, you would need to create an HTML template file called HiWorld.html in the same directory as your Flask application file<\/p>\n
<!DOCTYPE html>\r\n<html>\r\n<head>\r\n <title>Hi World!<\/title>\r\n<\/head>\r\n<body>\r\n <h1>Hello, World!<\/h1>\r\n<\/body>\r\n<\/html>\r\n<\/pre>\nGenerating additional HTML files<\/h3>\n
Rather than hardcoding the Content in the view function, Flask makes it possible to display the outside HTML file. Here, we may benefit from the flask’s underlying jinja2 template engine.
\nTo generate the external Html document that will be given as the result from the view function, utilise the render template() function that Flask offers.<\/p>\n
Consider the case below.<\/p>\n
Let’s first generate an HTML file with the name demo.html in order to produce a Html document from the view function.<\/p>\n
Demo.html<\/strong><\/p>\n<!DOCTYPE html>\r\n<html>\r\n<head>\r\n <title>Windows<\/title>\r\n<\/head>\r\n<body>\r\n <h1>Hello, World!<\/h1>\r\n<\/body>\r\n<\/html>\r\n<\/pre>\nFlask.py<\/strong><\/p>\nfrom flask import Flask, render_template\r\n\r\napp = Flask(__name__)\r\n\r\n@app.route('\/')\r\ndef content():\r\n return render_template('Demo.html')\r\n\r\n\r\nif __name__ == '__main__':\r\n app.run(debug=True)\r\n<\/pre>\nOutput:<\/strong><\/p>\nHello, World!<\/p>\n
This message is displayed in large font because it’s wrapped in an <h1> tag in the Demo.html template file.<\/strong><\/p>\nBuilding and Developing Template in Flask<\/h3>\n
Now that we have a means to really inherit some templates rather than just reuse them, we can accomplish this by building blocks in Jinja. With the name supplied to the block, we may use it in other templates and they enable us to create template blocks.<\/p>\n
Consequently, let’s build a block in our “index.html” file and reuse it. To do this, we start the block with “% block name>%” (where name = “body”); this will copy anything beyond it and save it in a synthetic block of template. To end the block, we simply type “% endblock%,” which will duplicate everything below it.<\/p>\n
demo.html<\/strong><\/p>\n<!DOCTYPE html>\r\n<html>\r\n<head>\r\n <title>Testing Flask<\/title>\r\n<\/head>\r\n<body>\r\n <h2>Welcome!<\/h2>\r\n <h4>Rendering Templates<\/h4>\r\n <a href=\"{{ url_for('home') }}\">Home<\/a>\r\n <a href=\"{{ url_for('index') }}\">Index<\/a>\r\n {% block body %}\r\n <p>Hello, world!<\/p>\r\n {% endblock %}\r\n<\/body>\r\n<\/html>\r\n<\/pre>\nBecause everything below the “% endblock%” and all above the “% block body%” tags is copied, we are excluding the “p>” tags in this instance. Additionally, we employ absolute urls. The hyperlinks are variable and rather simple to comprehend. As component of Jinja2 syntax, we wrap them with ” “. We only need to supply the function’s name as a text as an argument to have the url for function reverse the full URL for us.<\/p>\n
Create the template “home.html” with the following information so that we can reuse the constructed block “body” in future templates:<\/p>\n
folder1\/hello.html<\/p>\n
{% extends 'index.html' %}\r\n{% block body %}\r\n<p>Welcome to the World !!!<\/p>\r\n{% endblock %}\r\n<\/pre>\nEven though it appears to be two lines, this will also extend (but will not include) the demo.html. This is accomplished by parsing the section into the aforementioned template using the %extends file.html>% tags. Then, we may add whatever we want. If you use the include tag, the replacement paragraph won’t appear in the right spot on the index.html page. Even though it will produce an erroneous html file, the browser is so forgiving that you won’t know unless you check the source that was generated. It is necessary to properly nest the body text.<\/p>\n
The only remaining component is the path to home.html, so let’s also create it. Let’s update the “server.py file” with a new route.<\/p>\n
@app.route(\"\/hello\")\r\ndef hello():\r\n return render_template(\"hello.html\")\r\n<\/pre>\nDelimiters in Flask<\/h3>\n
To enable dynamic data representation in HTML, the Jinga 2 template engine offers a number of delimiters that can be employed.Characters provided by the templates system for variables and expressions are replaced by their real values when the template is rendered.<\/p>\n
The following delimiters are available from the jinga2 templates engine to escape from HTML.<\/p>\n
\n- {% … %} for lines<\/li>\n
- {{ … }} to display to the template result for expressions<\/li>\n
- {# … #} for the remarks that aren’t printed using the template<\/li>\n
- # … ## for lines of statements<\/li>\n<\/ul>\n
Take a look at the example below, where the {{…}} delimiter is used to display the variable portion of the URL in the HTML script.<\/p>\n
demo.html<\/strong><\/p>\n<!DOCTYPE html>\r\n<html>\r\n<head>\r\n <title>Hello World!<\/title>\r\n<\/head>\r\n<body>\r\n <h1>Hello, {{ name }}!<\/h1>\r\n<\/body>\r\n<\/html>\r\n<\/pre>\nServer.py<\/strong><\/p>\nfrom flask import Flask, render_template\r\n\r\napp = Flask(__name__)\r\n\r\n@app.route('\/user\/<u_name>')\r\ndef index(u_name):\r\n return render_template('demo.html', name=u_name)\r\n\r\nif __name__ == '__main__':\r\n app.run(debug=True)\r\n<\/pre>\nTemplate Logic Inference<\/h3>\n
For loops and if conditions are two ways to introduce logic into templates. This is really a fantastic feature to use. Without too much difficulty, we can make some fantastic dynamic templates. Let’s attempt rendering a list on an HTML template using Python.<\/p>\n
For this, we’ll construct a new route at “\/about,” which will connect to the method about, which generates the template “about.html,” but we’ll also add a few extra things before the function returns. We’ll make a list of fictitious strings and parse them before passing them to a render template method.<\/p>\n
from flask import Flask, render_template\r\n\r\napp = Flask(__name__)\r\n\r\n@app.route(\"\/test\")\r\ndef about():\r\n social_sites = ['Twitter', 'Instagram', 'Facebook', 'WhatsApp']\r\n return render_template(\"about.html\", sites=social_sites)\r\n\r\nif __name__ == '__main__':\r\n app.run(debug=True)\r\n<\/pre>\nIn order to link the about function to the route, we constructed the route at “\/test”. You can call them anything you like as long as you continue to include that title in the designs. Inside that function, we first create the list “Sites” with some dummy strings, and then, as we return, we parse them as sites. We’ll start by generating the “about.html” template and filling it with the information below.<\/p>\n
test.html<\/strong><\/p>\n{% extends 'base.html' %}\r\n\r\n{% block content %}\r\n <h1>List of Social Sites<\/h1>\r\n <ul>\r\n {% for site in sites %}\r\n <li>{{ site }}<\/li>\r\n {% endfor %}\r\n <\/ul>\r\n{% endblock %}\r\n<\/pre>\nOutput:<\/strong><\/p>\nList of Social Sites
\n– Twitter
\n– Instagram
\n– Facebook
\n– WhatsApp<\/p>\n
For loops can be used in templates that are enclosed in “%%,” and they can be called in a standard Python fashion. The variable (list) we read in the routing method is called the sites. The iterator may once more be used as a variable encased in quotation marks. This is similar to putting together a puzzle; to access a variable’s value, type “,” and to access any additional structures or blocks, type “%%.”<\/p>\n
<!DOCTYPE html>\r\n<html>\r\n<head>\r\n <title>FlaskTest<\/title>\r\n<\/head>\r\n<body>\r\n <h2> Hello Everyone!!! <\/h2>\r\n <h4>Flask: Rendering Templates<\/h4>\r\n <a href=\"{{ url_for('demo') }}\">Home<\/a>\r\n <a href=\"{{ url_for('test') }}\">About<\/a>\r\n {% block body %}\r\n<p>Flask Application is successfully implemented.<\/p>\r\n {% endblock %}\r\n<\/body>\r\n<\/html>\r\n<\/pre>\nFlask templates also support if-else statements. We can use it to generate dynamic templates in a manner reminiscent of the syntax for for loops. Let’s look at an illustration of a website position.<\/p>\n
Let’s construct the section contact’s path. This URL, “last\/func>,” is linked to the function last, which outputs the “last.html” template. This acknowledges the role of the argument. Here, we can notice several alterations that are merely semantic in nature. There is nothing novel about using the field person as a separate identifier in the templates where role values were assigned.<\/p>\n
@app.route(\"\/last\/<func>\")\r\ndef last(func):\r\n return render_template(\"last.html\", person=func)\r\n<\/pre>\nAs a result, the route is created as desired, and the variable role is parsed as a human to the design. Let’s start by making the template.<\/p>\n
last.html<\/strong><\/p>\n{% extends 'base.html' %}\r\n{% block content %}\r\n{% if user_type == \"admin\" %}\r\n<p> Welcome Admin <\/p>\r\n{% elif user_type == \"maintainer\" %}\r\n<p> Welcome Maintainer <\/p>\r\n{% elif user_type == \"member\" %}\r\n<p> Welcome Member <\/p>\r\n{% else %}\r\n<p> Hello, {{ person }}<\/p>\r\n{% endif %}\r\n{% endblock %}\r\n<\/pre>\nThe meaning of the variable person, which is retrieved from the URL and interpreted by the render template function, is therefore checked in the template. With merely “%%” enclosed, the the else syntax is comparable to that of Python. The code is rather self-explanatory because we build an if-elif and else ladders, check for a value, and then produce the necessary HTML elements.<\/p>\n
The output will depend on the value of the variable user_type passed to the template while rendering. For example, if user_type is “admin”, the output will be:<\/p>\n
Welcome Admin<\/strong><\/p>\nSimilarly, if user_type is “maintainer”, the output will be:<\/p>\n
Welcome Maintainer<\/strong><\/p>\nConclusion<\/h3>\n
Therefore, it is clear that now the template in Flask is producing the information in accordance with the role variable that was supplied in the URL. Avoid attempting to construct a Hyperlink for this because we must manually insert the role variable, therefore it would not function. To use it, a workaround must be implemented.
\nThat covered how to use and render templates in Flask. To develop some dynamic templates, we used Python and the Jinja templating syntax.<\/p>\n","protected":false},"excerpt":{"rendered":"
In this article, we will learn about template in flask Let’s start!! What are templates? Templates are scripts that include stand ins for data streams in addition to static data. To create the finished...<\/p>\n","protected":false},"author":581,"featured_media":114774,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[27373],"tags":[27625,27624],"class_list":["post-113243","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python-flask-tutorials","tag-flask-template","tag-templates-in-flask"],"yoast_head":"\n
Template in Flask - DataFlair<\/title>\n<meta name=\"description\" content=\"Templates are scripts that include stand ins for data streams in addition to static data. Learn Building and Developing Template in Flask.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/data-flair.training\/blogs\/flask-templates\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Template in Flask - DataFlair\" \/>\n<meta property=\"og:description\" content=\"Templates are scripts that include stand ins for data streams in addition to static data. Learn Building and Developing Template in Flask.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/data-flair.training\/blogs\/flask-templates\/\" \/>\n<meta property=\"og:site_name\" content=\"DataFlair\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/DataFlairWS\/\" \/>\n<meta property=\"article:published_time\" content=\"2023-07-22T13:37:38+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2023\/03\/flask-templates.webp\" \/>\n\t<meta property=\"og:image:width\" content=\"1200\" \/>\n\t<meta property=\"og:image:height\" content=\"628\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/webp\" \/>\n<meta name=\"author\" content=\"DataFlair Team\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:site\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"DataFlair Team\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"7 minutes\" \/>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Template in Flask - DataFlair","description":"Templates are scripts that include stand ins for data streams in addition to static data. Learn Building and Developing Template in Flask.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/data-flair.training\/blogs\/flask-templates\/","og_locale":"en_US","og_type":"article","og_title":"Template in Flask - DataFlair","og_description":"Templates are scripts that include stand ins for data streams in addition to static data. Learn Building and Developing Template in Flask.","og_url":"https:\/\/data-flair.training\/blogs\/flask-templates\/","og_site_name":"DataFlair","article_publisher":"https:\/\/www.facebook.com\/DataFlairWS\/","article_published_time":"2023-07-22T13:37:38+00:00","og_image":[{"width":1200,"height":628,"url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2023\/03\/flask-templates.webp","type":"image\/webp"}],"author":"DataFlair Team","twitter_card":"summary_large_image","twitter_creator":"@DataFlairWS","twitter_site":"@DataFlairWS","twitter_misc":{"Written by":"DataFlair Team","Est. reading time":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/data-flair.training\/blogs\/flask-templates\/#article","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/flask-templates\/"},"author":{"name":"DataFlair Team","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/c187795dc82ab948373cca526df7c445"},"headline":"Template in Flask","datePublished":"2023-07-22T13:37:38+00:00","mainEntityOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/flask-templates\/"},"wordCount":1545,"commentCount":0,"publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/flask-templates\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2023\/03\/flask-templates.webp","keywords":["flask template","Templates in Flask"],"articleSection":["Python Flask Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/data-flair.training\/blogs\/flask-templates\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/data-flair.training\/blogs\/flask-templates\/","url":"https:\/\/data-flair.training\/blogs\/flask-templates\/","name":"Template in Flask - DataFlair","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/#website"},"primaryImageOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/flask-templates\/#primaryimage"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/flask-templates\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2023\/03\/flask-templates.webp","datePublished":"2023-07-22T13:37:38+00:00","description":"Templates are scripts that include stand ins for data streams in addition to static data. Learn Building and Developing Template in Flask.","breadcrumb":{"@id":"https:\/\/data-flair.training\/blogs\/flask-templates\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/data-flair.training\/blogs\/flask-templates\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/flask-templates\/#primaryimage","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2023\/03\/flask-templates.webp","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2023\/03\/flask-templates.webp","width":1200,"height":628,"caption":"flask templates"},{"@type":"BreadcrumbList","@id":"https:\/\/data-flair.training\/blogs\/flask-templates\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Blog Home","item":"https:\/\/data-flair.training\/blogs\/"},{"@type":"ListItem","position":2,"name":"Python Flask Tutorials","item":"https:\/\/data-flair.training\/blogs\/category\/python-flask-tutorials\/"},{"@type":"ListItem","position":3,"name":"Template in Flask"}]},{"@type":"WebSite","@id":"https:\/\/data-flair.training\/blogs\/#website","url":"https:\/\/data-flair.training\/blogs\/","name":"DataFlair","description":"Learn Today. Lead Tomorrow.","publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/data-flair.training\/blogs\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/data-flair.training\/blogs\/#organization","name":"DataFlair","url":"https:\/\/data-flair.training\/blogs\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","width":106,"height":48,"caption":"DataFlair"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/DataFlairWS\/","https:\/\/x.com\/DataFlairWS","https:\/\/www.linkedin.com\/company\/dataflair-web-services-pvt-ltd\/","https:\/\/www.youtube.com\/user\/DataFlairWS"]},{"@type":"Person","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/c187795dc82ab948373cca526df7c445","name":"DataFlair Team","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/2302ebc438084d2f1f993edc1996a0aae01332e81f3227cba8df0c48ec010ca4?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/2302ebc438084d2f1f993edc1996a0aae01332e81f3227cba8df0c48ec010ca4?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/2302ebc438084d2f1f993edc1996a0aae01332e81f3227cba8df0c48ec010ca4?s=96&d=mm&r=g","caption":"DataFlair Team"},"description":"DataFlair Team provides high-impact content on programming, Java, Python, C++, DSA, AI, ML, data Science, Android, Flutter, MERN, Web Development, and technology. We make complex concepts easy to grasp, helping learners of all levels succeed in their tech careers.","url":"https:\/\/data-flair.training\/blogs\/author\/dfteam6\/"}]}},"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/113243","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/users\/581"}],"replies":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/comments?post=113243"}],"version-history":[{"count":7,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/113243\/revisions"}],"predecessor-version":[{"id":116762,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/113243\/revisions\/116762"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media\/114774"}],"wp:attachment":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media?parent=113243"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/categories?post=113243"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/tags?post=113243"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}