./textproc/py-jinja2, Small but fast and easy to use stand-alone template engine

[ CVSweb ] [ Homepage ] [ RSS ] [ Required by ] [ Add to tracker ]

Branch: CURRENT, Version: 2.11.2, Package name: py37-jinja2-2.11.2, Maintainer: pkgsrc-users

Jinja2 is a template engine written in pure Python. It provides a Django
inspired non-XML syntax but supports inline expressions and an optional
sandboxed environment.

Required to run:
[devel/py-setuptools] [devel/py-babel] [textproc/py-markupsafe] [lang/python37]

Required to build:

Master sites:

SHA1: 1017138fd4cb627204d3109b75c107c3d6f3f7fb
RMD160: b0ef9fa98df528591db62542ee7ded5b87b69480
Filesize: 251.557 KB

Version history: (Expand)

CVS history: (Expand)

   2020-04-14 14:10:03 by Adam Ciarcinski | Files touched by this commit (2) | Package updated
Log message:
py-jinja2: updated to 2.11.2

Version 2.11.2
Fix a bug that caused callable objects with __getattr__, like Mock to be treated \ 
as a contextfunction().
Update wordcount filter to trigger Undefined methods by wrapping the input in \ 
Fix a hang when displaying tracebacks on Python 32-bit.
Showing an undefined error for an object that raises AttributeError on access \ 
doesn’t cause a recursion error.
Revert changes to PackageLoader from 2.10 which removed the dependency on \ 
setuptools and pkg_resources, and added limited support for namespace packages. \ 
The changes caused issues when using Pytest. Due to the difficulty in supporting \ 
Python 2 and PEP 451 simultaneously, the changes are reverted until 3.0.
Fix line numbers in error messages when newlines are stripped.
The special namespace() assignment object in templates works in async environments.
Fix whitespace being removed before tags in the middle of lines when \ 
lstrip_blocks is enabled.
NativeEnvironment doesn’t evaluate intermediate strings during rendering. This \ 
prevents early evaluation which could change the value of an expression.
   2020-03-22 23:42:14 by Roland Illig | Files touched by this commit (1)
Log message:
textproc/py-jinja2: remove ignored SUBST block

The Python files are in src/jinja2, not jinja2. Since they haven't been
replaced in the past, it's probably ok to keep the few Unicode string
   2020-02-01 21:31:29 by Adam Ciarcinski | Files touched by this commit (2) | Package updated
Log message:
py-jinja2: updated to 2.11.1

Version 2.11.1
- Fix a bug that prevented looking up a key after an attribute
  (``{{ data.items[1:] }}``) in an async template.

Version 2.11.0
- Drop support for Python 2.6, 3.3, and 3.4. This will be the last
  version to support Python 2.7 and 3.5.
- Added a new ``ChainableUndefined`` class to support getitem and
  getattr on an undefined object.
- Allow ``{%+`` syntax (with NOP behavior) when ``lstrip_blocks`` is
- Added a ``default`` parameter for the ``map`` filter.
- Exclude environment globals from
- Float literals can be written with scientific notation, like
- Int and float literals can be written with the '_' separator for
  legibility, like 12_345.
- Fix a bug causing deadlocks in ``LRUCache.setdefault``.
- The ``trim`` filter takes an optional string of characters to trim.
- A new ``jinja2.ext.debug`` extension adds a ``{% debug %}`` tag to
  quickly dump the current context and available filters and tests.
- Lexing templates with large amounts of whitespace is much faster.
- Parentheses around comparisons are preserved, so
  ``{{ 2 * (3 < 5) }}`` outputs "2" instead of "False".
- Add new ``boolean``, ``false``, ``true``, ``integer`` and ``float``
- The environment's ``finalize`` function is only applied to the
  output of expressions (constant or not), not static template data.
- When providing multiple paths to ``FileSystemLoader``, a template
  can have the same name as a directory.
- Always return :class:`Undefined` when omitting the ``else`` clause
  in a ``{{ 'foo' if bar }}`` expression, regardless of the
  environment's ``undefined`` class. Omitting the ``else`` clause is a
  valid shortcut and should not raise an error when using
- Fix behavior of ``loop`` control variables such as ``length`` and
  ``revindex0`` when looping over a generator.
- Async support is only loaded the first time an environment enables
  it, in order to avoid a slow initial import.
- In async environments, the ``|map`` filter will await the filter
  call if needed.
- In for loops that access ``loop`` attributes, the iterator is not
  advanced ahead of the current iteration unless ``length``,
  ``revindex``, ``nextitem``, or ``last`` are accessed. This makes it
  less likely to break ``groupby`` results.
- In async environments, the ``loop`` attributes ``length`` and
  ``revindex`` work for async iterators.
- In async environments, values from attribute/property access will
  be awaited if needed.
- :class:`~loader.PackageLoader` doesn't depend on setuptools or
- ``PackageLoader`` has limited support for :pep:`420` namespace
- Support :class:`os.PathLike` objects in
  :class:`~loader.FileSystemLoader` and :class:`~loader.ModuleLoader`.
- :class:`~nativetypes.NativeTemplate` correctly handles quotes
  between expressions. ``"'{{ a }}', '{{ b }}'"`` renders as the tuple
  ``('1', '2')`` rather than the string ``'1, 2'``.
- Creating a :class:`~nativetypes.NativeTemplate` directly creates a
  :class:`~nativetypes.NativeEnvironment` instead of a default
- After calling ``LRUCache.copy()``, the copy's queue methods point to
  the correct queue.
- Compiling templates always writes UTF-8 instead of defaulting to the
  system encoding.
- ``|wordwrap`` filter treats existing newlines as separate paragraphs
  to be wrapped individually, rather than creating short intermediate
- Add ``break_on_hyphens`` parameter to ``|wordwrap`` filter.
- Cython compiled functions decorated as context functions will be
  passed the context.
- When chained comparisons of constants are evaluated at compile time,
  the result follows Python's behavior of returning ``False`` if any
  comparison returns ``False``, rather than only the last one.
- Tracebacks for exceptions in templates show the correct line numbers
  and source for Python >= 3.7.
- Tracebacks for template syntax errors in Python 3 no longer show
  internal compiler frames.
- Add a ``DerivedContextReference`` node that can be used by
  extensions to get the current context and local variables such as
- Constant folding during compilation is applied to some node types
  that were previously overlooked.
- ``TemplateSyntaxError.source`` is not empty when raised from an
  included template.
- Passing an ``Undefined`` value to ``get_template`` (such as through
  ``extends``, ``import``, or ``include``), raises an
  ``UndefinedError`` consistently. ``select_template`` will show the
  undefined message in the list of attempts rather than the empty
- ``TemplateSyntaxError`` can be pickled.
   2019-10-07 07:34:30 by Adam Ciarcinski | Files touched by this commit (3) | Package updated
Log message:
py-jinja2: updated to 2.10.3

Version 2.10.3
- Fix a typo in Babel entry point in ``setup.py`` that was preventing

Version 2.10.2
- Fix Python 3.7 deprecation warnings.
- Using ``range`` in the sandboxed environment uses ``xrange`` on
  Python 2 to avoid memory use.
- Use Python 3.7's better traceback support to avoid a core dump when
  using debug builds of Python 3.7.
   2019-04-07 18:05:38 by Adam Ciarcinski | Files touched by this commit (2) | Package updated
Log message:
py-jinja2: updated to 2.10.1

Version 2.10.1
- SandboxedEnvironment securely handles str.format_map in
  order to prevent code execution through untrusted format strings.
  The sandbox already handled str.format.
   2018-07-03 09:58:11 by Adam Ciarcinski | Files touched by this commit (1)
Log message:
py-jinja2: fix for Python 3.7
   2017-11-09 08:52:17 by Adam Ciarcinski | Files touched by this commit (3) | Package updated
Log message:
py-jinja2: updated to 2.10

Version 2.10:
- Added a new extension node called OverlayScope which can be used to
  create an unoptimized scope that will look up all variables from a
  derived context.
- Added an in test that works like the in operator.  This can be used
  in combination with reject and select.
- Added previtem and nextitem to loop contexts, providing access to the
  previous/next item in the loop. If such an item does not exist, the value is
- Added changed(*values) to loop contexts, providing an easy way of
  checking whether a value has changed since the last iteration (or rather
  since the last call of the method)
- Added a namespace function that creates a special object which allows
  attribute assignment using the set tag.  This can be used to carry data
  across scopes, e.g. from a loop body to code that comes after the loop.
- Added a trimmed modifier to {% trans %} to strip linebreaks and
  surrounding whitespace. Also added a new policy to enable this for all
  trans blocks.
- The random filter is no longer incorrectly constant folded and will
  produce a new random choice each time the template is rendered.
- Added a unique filter.
- Added min and max filters.
- Added tests for all comparison operators: eq, ne, lt, le,
  gt, ge.
- import statement cannot end with a trailing comma.
- indent filter will not indent blank lines by default.
- Add reverse argument for dictsort filter.
- Add a NativeEnvironment that renders templates to native Python types
  instead of strings.
- Added filter support to the block set tag.
- tojson filter marks output as safe to match documented behavior.
- Resolved a bug where getting debug locals for tracebacks could
  modify template context.
- Fixed a bug where having many {% elif ... %} blocks resulted in a
  "too many levels of indentation" error.  These blocks now compile to
  native elif ..: instead of else: if ..:
   2017-05-04 22:23:31 by Adam Ciarcinski | Files touched by this commit (2)
Log message:
PLIST fix for Python < 3.6