Implementation of Jinja2 Variables

[Nootaku]

First of all : Eel is amazing ! This is a project I'd love to participate with.

One of the features I find lacking is the implementation of Jinja Variables. While the documentation and the options allow for inserting and using templates (with the jinja_templates argument in the start() function), I did not see any possibility to transfer variables within the templates.

It would be nice if this could be included either as a decorator or in a more "flask-like" fashion in the return of a function.

One solution that I tried to fiddle with but to no avail, was to create a decorator for the _static function (in the __init__.py) that seems to handle Jinja's template.render() function.

Here's what I got so far:

def jinjaVariables(_static):
 def innerFunction(path, jinja_variable=None):
 # the decorator recieved a Jinja Variable
 if "jinja_variables" is not None:
 response = None
 if 'jinja_env' in _start_args and 'jinja_templates' in _start_args:
 template_prefix = _start_args['jinja_templates'] + '/'
 if path.startswith(template_prefix):
 n = len(template_prefix)
 template = _start_args['jinja_env'].get_template(path[n:])
 response = btl.HTTPResponse(template.render(jinja_variable))

 if response is None:
 response = btl.static_file(path, root=root_path)

 _set_response_headers(response)
 return response

 _static(path)

 return innerFunction

The idea was to create a global dictionary variable called jinja_variable and to update that variable depending on the page you want to visit.

If you were to include the jinja_variable in the kwargs of the start() function, wouldn't it be possible to dynamically change the output of the html page by accessing the required keys ?

[samuelhwilliams]

Hey @Nootaku - thanks for your interest in Eel!

You're definitely right that the implementation of jinja templating is a little lacking here, and being able to pass variables into the render calls does limit its utility.

I'd love to understand your use-case a little better so we can start to work out the best way forward. At the moment I'm not sure I understand your proposed solution or that it works for a general case. I'll start to have a think about it, but any details you can provide will help me understand where you're coming from.

Thanks!

[Nootaku]

Hey @samuelhwilliams - thank you for your swift answer.

I'm am a relatively inexperienced programmer, so the code above was simply something that I thought could be possible to integrate in the framework.

I'll try to be as short as possible, but here is my thought process:

• Based on what Flask does, it is possible to nest Jinja's template.render() function inside flask's render_template() function (see templating.py line 116 to 141). This means the arguments of Flask's render_template() function are being passed on to Jinja's template.render() function.
• Currently Eel does something similar in its _static() function.
• This means that it should be possible to modify the _static() function as follows (or something similar)

def _static(path, **context):
 """Arguments:
 		- path: path to the jinja template
 		- context: dictionary with
 			key = jinja variable name
 			value = jinja variable value
 """
 response = None
 if (
 'jinja_env' in _start_args and
 'jinja_templates' in _start_args
 ):
 template_prefix = _start_args['jinja_templates'] + '/'
 if path.startswith(template_prefix):
 n = len(template_prefix)
 template = _start_args['jinja_env'].get_template(path[n:])
 if context is not None:
 response = btl.HTTPRespons(
 template.render(context)
 )
 else:
 response = btl.HTTPRespons(
 template.render()
 )
 
 if response is None:
 response = btl.static_file(path, root=root_path)

 _set_response_headers(response)
 return response

• By doing this, the last problem we are facing is to provide the **context argument to _static() in a way that is possible for the user to send variable for each html-page he/she wants to load. To do so, I have two options that come to mind:
  1. the use of a decorator
  2. create an independant function

In both cases, taking Eel's structure in consideration, we should pass 2 arguments:

• a path_to_template
• the context_dictionary

I believe it might end up looking something like this (and it is what I tried to make last week):

@eel.jinja_variables(some_context_dictionary)
def load_template(path_to_template):
 html_page = eel.render_page(path_to_template, some_context_dictionary)
 return html_page

Cheers

[Nama]

It's making building html in for-loops waaaay cleaner.

I would just pass an object to the template and get the values in a for-loop. But for Eel, I have to get the values in a for-loop, run the python command from javascript and do another for-loop for building the html.

And putting in values in html is in jinja itself muuch fancier.

[forno96]

There's some update on this topic?
I'm falling in love with this project and having the possibility to pass context to jinja would be super helpfull

[eddyizm]

So am I correct in understanding that you can't pass a python variable to jinja or for example a data table?

[Khharua]

I also hope this will be implemented, before or (probably) later! 👯

[TadeasFrycak]

Hello, would it be possible to implement that, please? Just change of 1-2 lines of code in init.py is required:

Line 245 before:
response = btl.HTTPResponse(template.render())

Line 245 after:
response = btl.HTTPResponse(template.render(_start_args['jinja_context']))

And then optionally add 'jinja_context': None to _start_args on line 53