Ability to apply functions to piped components

[johnjosephhorton]

def to_years(months):
    return months/12
    
q1 = QuestionNumerical(question_text = """How old are you in months?""", question_name = "age")
q2 = QuestionFreeText(
    question_text = """What would someone who is {{ to_years(age.answer) }} years be interested in?""", 
     question_name = "interests")
s = Survey([q1, q2], custom_functions = [to_years])

This could be done like so, by changing the jinja2 environment:
https://claude.ai/share/2d5d73b9-876b-48bc-8cb6-4abc84fcc300

To implement:

1. Find all the python Environments for rendering templates & skip-logic
2. Add serializable "custom_functions" attribute to a Survey

[johnjosephhorton]

It's much better to do this with the existing jinja2 filters, which are quite flexible

# Jinja2 Built-in Filter Functions

## String Filters
- `capitalize` - Capitalizes the first character of the value
- `lower` - Converts a value to lowercase
- `upper` - Converts a value to uppercase
- `title` - Capitalizes each word in the value
- `trim` - Strips whitespace from the beginning and end
- `striptags` - Removes HTML/XML tags
- `replace(old, new[, count])` - Replaces occurrences of old with new
- `truncate(length=255, killwords=False, end='...')` - Truncates a string to a certain length
- `wordwrap(width=79, break_long_words=True)` - Wraps words at position width
- `indent(width=4, indentfirst=False)` - Indents lines with spaces or other character
- `escape` / `e` - Escapes HTML
- `forceescape` - Applies HTML escaping even if value is already escaped
- `urlize([trim_url_limit=None, nofollow=False])` - Converts URLs to clickable links
- `wordcount` - Counts words in the string

## List Filters
- `first` - Returns the first item of a sequence
- `last` - Returns the last item of a sequence
- `length` / `count` - Returns the number of items in a sequence
- `join(separator='')` - Joins a sequence with a string separator
- `sort` - Sorts a sequence
- `unique` - Removes duplicate elements from a sequence
- `map(attribute)` - Applies a filter on a sequence of objects
- `select(attribute)` - Filters a sequence of objects by applying a test
- `reject(attribute)` - Filters a sequence of objects by rejecting a test
- `selectattr(attribute, value)` - Filters based on attribute value
- `rejectattr(attribute, value)` - Rejects based on attribute value
- `reverse` - Reverses a sequence
- `random` - Returns a random item
- `batch(linecount)` - Batches items 
- `slice(start, stop, step=1)` - Slices a sequence

## Math Filters
- `abs` - Returns the absolute value
- `round(precision=0, method='common')` - Rounds numbers
- `int` - Converts to an integer
- `float` - Converts to a float
- `sum` - Returns the sum of items in the sequence
- `max` - Returns the largest item
- `min` - Returns the smallest item

## Logic/Test Filters
- `default(value, default_value='')` - Returns the value or a default value if empty
- `defined` - Returns true if the variable is defined
- `divisibleby(num)` - Checks if value is divisible by a number
- `even` - Checks if number is even
- `odd` - Checks if number is odd
- `iterable` - Checks if object is iterable
- `none` - Returns true if the variable is None
- `sameas(other)` - Tests if both objects point to the same memory location
- `tojson` - Dumps an object to JSON

## Date Filters
- `datetimeformat` - Formats datetime objects
- `dateformat` - Formats date objects
- `timeformat` - Formats time objects

## Encoding Filters
- `base64encode` - Encodes string to base64
- `base64decode` - Decodes base64 string
- `urlencode` - URL-encodes a string

## Conversion Filters
- `list` - Converts value to a list
- `string` - Converts value to a string
- `dictsort(case_sensitive=False, by='key')` - Sorts a dict and yields (key, value) pairs

We should add an ability to pass variables created in question to the subsequent questions:

from jinja2 import Environment, Template

# Class to capture template variables from the Jinja2 template
class TemplateVars:
    def __init__(self):
        self.data = {}
    
    def set(self, name, value):
        """Store a variable with its name and value"""
        self.data[name] = value
        return ""  # Return empty to avoid outputting anything in the template
    
    def get(self, name, default=None):
        """Retrieve a stored variable"""
        return self.data.get(name, default)
    
    def get_all(self):
        """Return all captured variables"""
        return self.data

# Sample data for our market simulation
scenario_data = {
    'players': ['Alice', 'Bob', 'Charlie', 'Dave'],
    'value': {
        'Alice': 100,
        'Bob': 120,
        'Charlie': 90,
        'Dave': 110
    }
}

# The template as a string
template_string = """
You are a buyer in a market.
{% set player = scenario.players | random %}
{{ vars.set('player', player) }}

{% set value = scenario.value[player] %}
{{ vars.set('value', value) }}

{% set min_bid = value * 0.7 %}
{{ vars.set('min_bid', min_bid) }}

{% set max_bid = value * 0.9 %}
{{ vars.set('max_bid', max_bid) }}

{% set bid = (min_bid + max_bid) / 2 %}
{{ vars.set('bid', bid) }}

Your name is {{ player }}.
Your value for the commodity is {{ value }}.
You can call out a bid to other traders in the market. 
You would be happy to get the good at your value, but you'd like to get it for less.
Any price you pay less than your value is pure profit.

Your strategic bid (70-90% of your value): {{ bid }}
"""

# Setup Jinja environment
env = Environment()
template = env.from_string(template_string)

# Create our variable collector
template_vars = TemplateVars()

# Render the template
rendered_text = template.render(
    scenario=scenario_data,
    vars=template_vars
)

# Display the rendered template
print("=== RENDERED TEMPLATE ===")
print(rendered_text)

# Display the captured variables
print("\n=== CAPTURED VARIABLES ===")
for name, value in template_vars.get_all().items():
    print(f"{name}: {value}")

[johnjosephhorton]

We can use macros to define functions (and jinja2 is Turing complete!):

NB: we could use the edsl Instruction to store macros