Use Jinja in Quickbase pipelines

abs
(x, /)

Return the absolute value of the argument.

base64_encode(value)

Encode a string using Base64 and return the encoded bytes.

Example of usage: {{‘Test string’ | base64_encode}} output: VGVzdCBzdHJpbmc=

base64_decode(value)

Decode the Base64 encoded string and return the decoded bytes.

Use the parameter output_encoding='binary' to select the format of the decoded output.
Outputs can be formatted as a string (default) or as bytes.

Example of usage: {{‘VGVzdCBzdHJpbmc=’ | base64_decode}} output: Test string

capitalize
(s)

Capitalize a value. The first character is uppercase, all others lowercase.

default
(value, default_value='', boolean=False)

If the value is undefined it will return the passed default value, otherwise the value of the variable:

{{ my_variable|default('my_variable is not defined') }}

{{ QB_VARIABLE | default(42) }}

Note: If the variable ‘QB_VARIABLE’ is not defined, the value used will be 42.

escape
(s)

Convert the characters &, <, >, ‘, and ” in strings to HTML-safe sequences. Use this if you need to display text that might contain such characters in HTML. Marks return value as markup string.

first
(seq)

Return the first item of a sequence.

{{ [1,2,3] | first}} output: 1

float
(value, default=0.0)

Convert the value into a floating point number. If the conversion doesn’t work it will return 0.0. You can override this default using the first parameter.

For example, the float and int are just added like so: {{a.value|float}} and {{a.value|int}}. Replace would be {{a.value|replace("$","") for example. This would remove a $ sign without leaving a space.

format
(value, *args, **kwargs)

Apply the given values to a printf-style format string, like string % values.

From JSON

hmac

Use this filter to wrap sensitive data with a specific key and algorithm, so it can later be used for additional verification or authentication steps.

Use the parameter output_encoding='binary' to return the output in binary representation.

int
(value, default=0, base=10)

Convert the value into an integer. If the conversion doesn’t work it will return 0. You can override this default using the first parameter. You can also override the default base (10) in the second parameter, which handles input with prefixes such as 0b, 0o and 0x for bases 2, 8 and 16 respectively. The base is ignored for decimal numbers and non-string values.

For example, the float and int are just added like so: {{a.value|float}} and {{a.value|int}}. Replace would be {{a.value|replace("$","") for example. This would remove a $ sign without leaving a space.

join
(value, d='', attribute=None)

Return a string which is the concatenation of the strings in the sequence. The separator between elements is an empty string per default, you can define it with the optional parameter:

{{ [1, 2, 3]|join('|') }} output: 1|2|3
{{ [1, 2, 3]|join }} output: 123

It is also possible to join certain attributes of an object:

{{ users|join(', ', attribute='username') }}

last
(seq)

Return the last item of a sequence

length
(obj, /)

Return the number of items in a container.

list
(value)

Convert the value into a list. If it was a string the returned list will be a list of characters.

lower
(s)

Convert a value to lowercase.

map
(*args, **kwargs)

Applies a filter on a sequence of objects or looks up an attribute

{{ titles|map('lower')|join(', ') }}

max
(value, case_sensitive=False, attribute=None) only in the latest

Return the largest item from the sequence.

{{ [1, 2, 3]|max }} output: 3

md5
(text)

Returns MD5 hex-digest string generated from the text input.

Example usage:

{{ "some text" | md5 }}
output: 552e21cd4cd9918678e3c1a0df491bc3

min
(value, case_sensitive=False, attribute=None)
only in the latest

Return the smallest item from the sequence.

{{ [1, 2, 3]|min }} output: 1

random
(seq)

Return a random item from the sequence.

reject
(*args, **kwargs)

Filters a sequence of objects by applying a test to each object, and rejecting the objects with the test succeeding.

If no test is specified, each object will be evaluated as a boolean.

Example usage:

{{ numbers|reject("odd") }}

replace
(s, old, new, count=None)

Return a copy of the value with all occurrences of a substring replaced with a new one. The first argument is the substring that should be replaced, the second is the replacement string. If the optional third argument count is given, only the first count occurrences are replaced:

{{ "Hello World"|replace("Hello", "Goodbye") }} output: Goodbye World

round
(value, precision=0, method='common')

Round the number to a given precision. The first parameter specifies the precision (default is 0), the second the rounding method:

• 'common' rounds either up or down

• 'ceil' always rounds up

• 'floor' always rounds down

• If you don’t specify a method 'common' is used.

{{ 42.55|round }}output: 43.0

select
(*args, **kwargs)

Filters a sequence of objects by applying a test to each object, and only selecting the objects with the test succeeding. If no test is specified, each object will be evaluated as a boolean.

Example usage:

{{ numbers|select("odd") }}
{{ numbers|select("odd") }}
{{ numbers|select("divisibleby", 3) }}
{{ numbers|select("lessthan", 42) }}
{{ strings|select("equalto", "mystring") 

{%- for column in [1, 2, 3]| select("odd")%}
{{column}}
{%- endfor %}
output: 1 and 3

sha1
(text)

Returns SHA1 hex-digest string generated from the text input.

Example usage:

{{ "some text" | sha1 }}
output: 37aa63c77398d954473262e1a0057c1e632eda77

sha224
(text)

Returns SHA224 hex-digest string generated from the text input.

Example usage:

{{ "some text" | sha224 }}
output: 9e13fe8526578d5792074d5bcaa9f222df928c7c158804ac70e904f8

sha256
(text)

Returns SHA256 hex-digest string generated from the text input.

Example usage:

{{ "some text" | sha256 }}
output: b94f6f125c79e3a5ffaa826f584c10d52ada669e6762051b826b55776d05aed2

sha384
(text)

Returns SHA384 hex-digest string generated from the text input.

Example usage:

{{ "some text" | sha384 }}
output: cc94ec3e9873c0b9a72486442958f671067cdf77b9427416d031440cc62041e2ee1344498447ec0ced9f7043461bd1f3

sha512
(text)

Returns SHA512 hex-digest string generated from the text input.

Example usage:

{{ "some text" | sha512 }}
output: e2732baedca3eac1407828637de1dbca702c3fc9ece16cf536ddb8d6139cd85dfe7464b8235b29826f608ccf4ac643e29b19c637858a3d8710a59111df42ddb5
                                        

slice
(value, slices, fill_with=None)

Slice an iterator and return a list of lists containing those items. Useful if you want to create a div containing three ul tags that represent columns:

{%- for column in [1,2,3,4]|slice(2)%}
       {{column}}
{%- endfor %}
output: [1, 2] [3, 4]

sort
(value, reverse=False, case_sensitive=False, attribute=None)

Sort an iterable

{%- for column in [4,2,3,4]|sort%}
       {{column}}
{%- endfor %}
output: 2 3 4 4

{% for user users|sort(attribute="age,name") %} ...{% endfor %}

string
(object)

Make a string unicode if it isn’t already. In this way, a markup string will not be converted back to unicode.

striptags
(value)

Strip SGML/XML tags and replace adjacent whitespace by one space.

{{ "foo"| striptags}} output: foo

sum
(iterable, attribute=None, start=0)

Returns the sum of a sequence of numbers plus the value of parameter ‘start’ (which defaults to 0). When the sequence is empty it returns start.

{{ [1,2,3]|sum }} output 6

It is also possible to sum up only certain attributes:

Total: {{ items|sum(attribute='price') }}

timestamp_to_time (value)

Converts UNIX timestamp to UTC Date Time format.

Example of usage:

input : {{1608112432| timestamp_to_time}}

output: 12-16-2020 01:53 AM

title
(s)

Return a titlecased version of the value. This means that words start with uppercase letters, all remaining characters are lowercase.

{{ "hello world" | title }} output: text:Hello World

tojson
(value, indent=None)
only in the latest

Dumps the structure to JSON so that it’s safe to use in <script> tags. It accepts the same arguments and returns a JSON string. Note that this is available in templates through the |tojson filter which will also mark the result as safe. Due to how this function escapes certain characters this is safe even if used outside of <script> tags.

The following characters are escaped in strings:

• <

• >

• &

• '

trim

(value, chars=None)

Strip leading and trailing characters, by default whitespace.

truncate

(s, length=255, killwords=False, end='...', leeway=None)

Return a truncated copy of the string.

{{ "foo bar baz qux"|truncate(9) }} output: foo...

unique

(value, case_sensitive=False, attribute=None)

only in the latest

Returns a list of unique items from the given iterable.

{{ ['hello', 'world', 'helloworld', 'HelloWorld']|unique|list }} output: ['hello', 'world', 'helloworld']

upper

(s)

Convert a value to uppercase.

urlencode

(value)

Quote data for use in a URL path or query using UTF-8.

wordcount

(s)

Count the words in that string.

Boolean

Return true if the object is a boolean value

Defined

Return true if the variable is defined

Divisibleby

Checks if a variable is divisible by a number

Even

Return true if the variable is even

Float

Return true if the object is a float

Ge

Whether or not the number is greater than or equal to

Gt

Whether or not the number is greater than

In

In a sequence

Integer

If an integer

Le

Less than or equal to

Lt

Less than

Mapping

Return true if the object is a mapping (dict etc.)

Ne

Not equal

None

True if the variable is none

Number

True if the variable is a number

Odd

True if the variable is odd

Sequence

Whether or not the variable is a sequence

String

True

<

>

&

‘