Iris Templates

A modern, secure, and flexible template rendering engine for Python developers.

Introduction

Iris Templates, developed and maintained by Altxria Inc., is a feature-rich, Python-based template rendering engine designed for developers seeking a modern, secure, and high-performance templating solution. It simplifies creating dynamic and modular HTML or text content with support for advanced directives, dynamic context evaluation, and reusable templates.

With a focus on developer efficiency, Iris Templates is inspired by popular templating engines like Blade and Jinja2, but takes them a step further by offering enhanced directives, security, and caching mechanisms.

Features

Advanced Directives

Iris supports powerful directives such as @if, @foreach, @extends, and more, making complex template logic simple and efficient.

Secure Context Evaluation

Safely evaluate dynamic Python expressions in templates, with built-in protection against unsafe operations.

High Performance

Includes a caching system to boost rendering speeds for repeated templates, ensuring low latency even with complex data.

Ease of Use

Designed for developers familiar with templating engines like Blade, Jinja2, or Django, Iris provides a seamless transition with a modern syntax.

Customizable and Modular

Extend directives, customize parsing logic, and build modular templates with ease.

About Altxria Inc.

Altxria Inc. is dedicated to providing developers with cutting-edge tools that simplify and enhance their workflows. Our commitment to quality and innovation drives us to create robust solutions like Iris Templates, empowering developers to build better, faster, and more secure applications.

For more details about our projects and open-source contributions, visit our GitHub profile or explore our website.

Installation

Install Iris Templates using pip:

pip install iris-templates

Why Use Iris Templates?

Feature	Iris Templates	Jinja2	Django Templates	Mako
Pythonic Templating	✅	✅	✅	✅
Advanced Directives	✅	❌	Limited	Limited
Embeddable Python Blocks	✅	❌	❌	✅
Caching	✅	❌	Limited	✅
Secure Context Evaluation	✅	✅	✅	❌
Easy to Learn	✅	✅	✅	❌

Examples

Initializing the Template Engine

In the first example, we demonstrate how to initialize the TemplateEngine. Both arguments—template_dir and cache_enabled—are optional. By default:

template_dir: The engine will look for a root folder named templates where it can find partials, layouts, or pages.
cache_enabled: The caching system is enabled to improve performance.


  from iris.engine import TemplateEngine
  
  # Initialize the template engine with a specified template directory and cache enabled.
  engine = TemplateEngine(template_dir="./templates", cache_enabled=True)
  
  # Define the context data for the template
  context = {"user": {"name": "Alice", "is_admin": True}}
  
  # Render the 'home.html' template with the provided context
  output = engine.render("pages/home.html", context)
  
  # Print the rendered output
  print(output)

Render from String

The second example shows how to render a template directly from a string using render_string. This method is useful for small, dynamic templates that do not need to be stored as files. Note that you can pass the same context object as with file-based templates.


  # Define a template string with a conditional directive
  template_string = """
  @if(user['is_admin'])
      Welcome Admin!
  @endif
  """
  
  # Define the context data
  context = {"user": {"name": "Alice", "is_admin": True}}
  
  # Render the template string with the context
  output = engine.render_string(template_string, context)
  
  # Print the rendered output
  print(output)

Directives

Conditional Logic (@if, @elseif, @else)


@if(user['is_admin'])
    Welcome Admin!
@elseif(user['is_moderator'])
    Welcome Moderator!
@else
    Welcome Guest!
@endif

Loops (@for, @foreach)


@for 
    i in range(5)
        Number: {{ i }}
@endfor
  
@foreach 
    item in items
        Item: {{ item }}
@endforeach

Switch Statements (@switch, @case, @default)


@switch(status)
    @case('success')
        Operation Successful
    @break
    @case('error')
        Error Occurred
    @break
    @default
        Status Unknown
@endswitch

Template Inheritance (@extends, @section, @yield)


// layouts/base.html
@yield('title', 'Default Title')

    @yield('content')


// pages/home.html
@extends('layouts/base.html')
@section('title', 'Home Page')

@section('content')
Here the content
@endsection

Template Inclusion (@include)


// partials/navbar.html

    Home
    About
    Contact


// layouts/base.html
@include('partials/navbar.html')

    @yield('content')

Context Checks (@isset & @empty)


@isset(user)
    User is set: {{ user['name'] }}
@endisset

@empty(orders)
    No orders found.
@endempty

Embeddable Python Code (@python)


@python
    result = sum(range(5))
@endpython
  
Sum of first 5 numbers: {!! result !!}

Template Syntax

Example Usage


@extends('layouts/base.html')
@section('title', 'Home Page')
  
@section('content')
  
@python
    i = 0
@endpython
  
Counter: {{ i }}
  
@isset('user')
    Welcome {{ user['name'] }}
@endisset
  
@empty('orders')
    No orders available.
@endempty
  
@for 
    i in range(5)
      Iteration: {{ i }}
@endfor
  
@switch(status)
    @case('success')
        Operation completed successfully.
    @break
    @default
        Unknown status.
@endswitch

@endsection

API Reference

TemplateEngine Class

The TemplateEngine is the core class for rendering templates dynamically with context data. It provides methods to process and render both files and raw template strings.

render(template_name, context): Render a template file with the given context.
render_string(template_string, context): Render a raw template string with the provided context.


  from iris.engine import TemplateEngine
  
  # Initialize the TemplateEngine
  engine = TemplateEngine(template_dir="./templates")
  
  # Render a template file
  context = {"user": "Alice"}
  output = engine.render("home.html", context)
  
  # Output the rendered result
  print(output)

Caching Mechanism

Iris includes a built-in caching mechanism to improve performance during repeated renders. This feature allows templates to be cached for faster access, reducing parsing time.

is_cached(template_name, context): Check if a template is cached for the specified context.
store(template_name, context, rendered_output): Store a rendered template and its context in the cache.
get(template_name, context): Retrieve a cached template if available.


  from iris.engine import TemplateEngine
  
  # Enable caching
  engine = TemplateEngine(template_dir="./templates", cache_enabled=True)
  
  # Render and cache a template
  context = {"user": "Alice"}
  output = engine.render("home.html", context)
  
  # Check if the template is cached
  is_cached = engine.cache.is_cached("home.html", context)
  print(f"Cached: {is_cached}")

Contribute to Iris

We warmly welcome contributions to Iris Templates! Whether it's fixing bugs, improving documentation, or adding new features, your input is invaluable.

How to Contribute

Fork the GitHub repository.
Clone your fork and create a new branch for your changes.
Submit a pull request with a detailed description of your changes.

For guidelines on contributing, refer to our Contribution Guide.