golden hour

/lib/python3.9/site-packages/ansible/plugins/filter

File/Folder	Size	Actions
__init__.py	510 B
__pycache__	-
b64decode.yml	927 B
b64encode.yml	543 B
basename.yml	809 B
bool.yml	631 B
checksum.yml	524 B
combinations.yml	780 B
combine.yml	1.63 KB
comment.yml	2.09 KB
core.py	21.05 KB
dict2items.yml	1.28 KB
difference.yml	1024 B
dirname.yml	820 B
encryption.py	2.63 KB
expanduser.yml	506 B
expandvars.yml	569 B
extract.yml	1.34 KB
fileglob.yml	589 B
flatten.yml	846 B
from_json.yml	905 B
from_yaml.yml	959 B
from_yaml_all.yml	1.25 KB
hash.yml	861 B
human_readable.yml	993 B
human_to_bytes.yml	1.02 KB
intersect.yml	969 B
items2dict.yml	1.52 KB
log.yml	904 B
mandatory.yml	537 B
mathstuff.py	8.12 KB
md5.yml	709 B
password_hash.yml	1.09 KB
path_join.yml	846 B
permutations.yml	969 B
pow.yml	692 B
product.yml	1.87 KB
quote.yml	492 B
random.yml	1.16 KB
realpath.yml	546 B
regex_escape.yml	688 B
regex_findall.yml	1.12 KB
regex_replace.yml	1.47 KB
regex_search.yml	1.04 KB
rekey_on_member.yml	921 B
relpath.yml	758 B
root.yml	618 B
sha1.yml	729 B
shuffle.yml	685 B
split.yml	833 B
splitext.yml	746 B
strftime.yml	1.33 KB
subelements.yml	1.4 KB
symmetric_difference.yml	1 KB
ternary.yml	1.52 KB
to_datetime.yml	1.58 KB
to_json.yml	2.69 KB
to_nice_json.yml	2.21 KB
to_nice_yaml.yml	1.55 KB
to_uuid.yml	785 B
to_yaml.yml	1.64 KB
type_debug.yml	508 B
union.yml	954 B
unique.yml	839 B
unvault.yml	1.04 KB
urldecode.yml	1.53 KB
urls.py	508 B
urlsplit.py	2.56 KB
vault.yml	1.63 KB
win_basename.yml	673 B
win_dirname.yml	679 B
win_splitdrive.yml	819 B
zip.yml	1.32 KB
zip_longest.yml	1.23 KB

Edit: mathstuff.py

# Copyright 2014, Brian Coca <bcoca@ansible.com>
# Copyright 2017, Ken Celenza <ken@networktocode.com>
# Copyright 2017, Jason Edelman <jason@networktocode.com>
# Copyright 2017, Ansible Project
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

# Make coding more python3-ish
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

import itertools
import math

from collections.abc import Hashable, Mapping, Iterable

from jinja2.filters import pass_environment

from ansible.errors import AnsibleFilterError, AnsibleFilterTypeError
from ansible.module_utils.common.text import formatters
from ansible.module_utils.six import binary_type, text_type
from ansible.module_utils._text import to_native, to_text
from ansible.utils.display import Display

try:
    from jinja2.filters import do_unique
    HAS_UNIQUE = True
except ImportError:
    HAS_UNIQUE = False

display = Display()

@pass_environment
# Use case_sensitive=None as a sentinel value, so we raise an error only when
# explicitly set and cannot be handle (by Jinja2 w/o 'unique' or fallback version)
def unique(environment, a, case_sensitive=None, attribute=None):

def _do_fail(e):
        if case_sensitive is False or attribute:
            raise AnsibleFilterError("Jinja2's unique filter failed and we cannot fall back to Ansible's version "
                                     "as it does not support the parameters supplied", orig_exc=e)

error = e = None
    try:
        if HAS_UNIQUE:
            c = list(do_unique(environment, a, case_sensitive=bool(case_sensitive), attribute=attribute))
    except TypeError as e:
        error = e
        _do_fail(e)
    except Exception as e:
        error = e
        _do_fail(e)
        display.warning('Falling back to Ansible unique filter as Jinja2 one failed: %s' % to_text(e))

if not HAS_UNIQUE or error:

# handle Jinja2 specific attributes when using Ansible's version
        if case_sensitive is False or attribute:
            raise AnsibleFilterError("Ansible's unique filter does not support case_sensitive=False nor attribute parameters, "
                                     "you need a newer version of Jinja2 that provides their version of the filter.")

c = []
        for x in a:
            if x not in c:
                c.append(x)

return c

@pass_environment
def intersect(environment, a, b):
    if isinstance(a, Hashable) and isinstance(b, Hashable):
        c = set(a) & set(b)
    else:
        c = unique(environment, [x for x in a if x in b], True)
    return c

@pass_environment
def difference(environment, a, b):
    if isinstance(a, Hashable) and isinstance(b, Hashable):
        c = set(a) - set(b)
    else:
        c = unique(environment, [x for x in a if x not in b], True)
    return c

@pass_environment
def symmetric_difference(environment, a, b):
    if isinstance(a, Hashable) and isinstance(b, Hashable):
        c = set(a) ^ set(b)
    else:
        isect = intersect(environment, a, b)
        c = [x for x in union(environment, a, b) if x not in isect]
    return c

@pass_environment
def union(environment, a, b):
    if isinstance(a, Hashable) and isinstance(b, Hashable):
        c = set(a) | set(b)
    else:
        c = unique(environment, a + b, True)
    return c

def logarithm(x, base=math.e):
    try:
        if base == 10:
            return math.log10(x)
        else:
            return math.log(x, base)
    except TypeError as e:
        raise AnsibleFilterTypeError('log() can only be used on numbers: %s' % to_native(e))

def power(x, y):
    try:
        return math.pow(x, y)
    except TypeError as e:
        raise AnsibleFilterTypeError('pow() can only be used on numbers: %s' % to_native(e))

def inversepower(x, base=2):
    try:
        if base == 2:
            return math.sqrt(x)
        else:
            return math.pow(x, 1.0 / float(base))
    except (ValueError, TypeError) as e:
        raise AnsibleFilterTypeError('root() can only be used on numbers: %s' % to_native(e))

def human_readable(size, isbits=False, unit=None):
    ''' Return a human readable string '''
    try:
        return formatters.bytes_to_human(size, isbits, unit)
    except TypeError as e:
        raise AnsibleFilterTypeError("human_readable() failed on bad input: %s" % to_native(e))
    except Exception:
        raise AnsibleFilterError("human_readable() can't interpret following string: %s" % size)

def human_to_bytes(size, default_unit=None, isbits=False):
    ''' Return bytes count from a human readable string '''
    try:
        return formatters.human_to_bytes(size, default_unit, isbits)
    except TypeError as e:
        raise AnsibleFilterTypeError("human_to_bytes() failed on bad input: %s" % to_native(e))
    except Exception:
        raise AnsibleFilterError("human_to_bytes() can't interpret following string: %s" % size)

def rekey_on_member(data, key, duplicates='error'):
    """
    Rekey a dict of dicts on another member

May also create a dict from a list of dicts.

duplicates can be one of ``error`` or ``overwrite`` to specify whether to error out if the key
    value would be duplicated or to overwrite previous entries if that's the case.
    """
    if duplicates not in ('error', 'overwrite'):
        raise AnsibleFilterError("duplicates parameter to rekey_on_member has unknown value: {0}".format(duplicates))

new_obj = {}

# Ensure the positional args are defined - raise jinja2.exceptions.UndefinedError if not
    bool(data) and bool(key)

if isinstance(data, Mapping):
        iterate_over = data.values()
    elif isinstance(data, Iterable) and not isinstance(data, (text_type, binary_type)):
        iterate_over = data
    else:
        raise AnsibleFilterTypeError("Type is not a valid list, set, or dict")

for item in iterate_over:
        if not isinstance(item, Mapping):
            raise AnsibleFilterTypeError("List item is not a valid dict")

try:
            key_elem = item[key]
        except KeyError:
            raise AnsibleFilterError("Key {0} was not found".format(key))
        except TypeError as e:
            raise AnsibleFilterTypeError(to_native(e))
        except Exception as e:
            raise AnsibleFilterError(to_native(e))

# Note: if new_obj[key_elem] exists it will always be a non-empty dict (it will at
        # minimum contain {key: key_elem}
        if new_obj.get(key_elem, None):
            if duplicates == 'error':
                raise AnsibleFilterError("Key {0} is not unique, cannot correctly turn into dict".format(key_elem))
            elif duplicates == 'overwrite':
                new_obj[key_elem] = item
        else:
            new_obj[key_elem] = item

return new_obj

class FilterModule(object):
    ''' Ansible math jinja2 filters '''

def filters(self):
        filters = {
            # exponents and logarithms
            'log': logarithm,
            'pow': power,
            'root': inversepower,

# set theory
            'unique': unique,
            'intersect': intersect,
            'difference': difference,
            'symmetric_difference': symmetric_difference,
            'union': union,

# combinatorial
            'product': itertools.product,
            'permutations': itertools.permutations,
            'combinations': itertools.combinations,

# computer theory
            'human_readable': human_readable,
            'human_to_bytes': human_to_bytes,
            'rekey_on_member': rekey_on_member,

# zip
            'zip': zip,
            'zip_longest': itertools.zip_longest,

}

return filters