Content generation system for creating complex visual elements including ASCII art text, images, charts, patterns, and media playback. Renderers provide the visual content that effects display, supporting both static and dynamic content generation with extensive customization options.
The renderer hierarchy provides the foundation for all content generation, with specialized classes for static and dynamic content.
class Renderer:
"""Abstract base class for all content renderers"""
def render(self, frame):
"""
Render content for specified frame number.
Parameters:
- frame (int): Frame number for animation timing
Returns:
list: List of strings representing rendered content lines
"""
@property
def max_height(self):
"""Maximum height of rendered content"""
@property
def max_width(self):
"""Maximum width of rendered content"""
class StaticRenderer(Renderer):
"""Base class for static (non-animated) content renderers"""
def __init__(self):
"""Initialize static renderer"""
class DynamicRenderer(Renderer):
"""Abstract base class for dynamic (animated) content renderers"""
def __init__(self, height, width):
"""
Initialize dynamic renderer with dimensions.
Parameters:
- height (int): Renderer height
- width (int): Renderer width
"""Specialized renderers for creating ASCII art text and formatted text displays.
class FigletText(StaticRenderer):
"""ASCII art text renderer using figlet fonts"""
def __init__(self, text, font='3x5', width=80, colour=7):
"""
Initialize figlet text renderer.
Parameters:
- text (str): Text to render as ASCII art
- font (str): Figlet font name ('3x5', 'big', 'slant', etc.)
- width (int): Maximum width for text wrapping
- colour (int): Text color
"""
class SpeechBubble(StaticRenderer):
"""Speech bubble text renderer with customizable appearance"""
def __init__(self, text, tail=None, uni=False):
"""
Initialize speech bubble renderer.
Parameters:
- text (str): Text content for speech bubble
- tail (str): Tail direction ('L', 'R' for left/right, None for no tail)
- uni (bool): Whether to use unicode characters for drawing
"""Renderers for creating geometric shapes, patterns, and drawing primitives.
class Box(StaticRenderer):
"""Rectangle/box drawing renderer"""
def __init__(self, width, height, uni=False):
"""
Initialize box renderer.
Parameters:
- width (int): Box width
- height (int): Box height
- uni (bool): Whether to use unicode line drawing characters
"""
class Rainbow(StaticRenderer):
"""Rainbow color gradient effect renderer"""
def __init__(self, screen, x, y, text):
"""
Initialize rainbow text renderer.
Parameters:
- screen (Screen): Target screen for color calculation
- x (int): Starting X position
- y (int): Starting Y position
- text (str): Text to apply rainbow effect to
"""
class Scale(StaticRenderer):
"""Horizontal scale/ruler renderer"""
def __init__(self, width, colour=7, bg=0, uni=False):
"""
Initialize horizontal scale renderer.
Parameters:
- width (int): Scale width
- colour (int): Scale color
- bg (int): Background color
- uni (bool): Whether to use unicode characters
"""
class VScale(StaticRenderer):
"""Vertical scale/ruler renderer"""
def __init__(self, height, colour=7, bg=0, uni=False):
"""
Initialize vertical scale renderer.
Parameters:
- height (int): Scale height
- colour (int): Scale color
- bg (int): Background color
- uni (bool): Whether to use unicode characters
"""Data visualization renderers for creating charts and graphs in text mode.
class BarChart(StaticRenderer):
"""Horizontal bar chart renderer"""
def __init__(self, height, width, functions, colour=7, bg=0, gradient=None, scale=None, axes=True, intervals=None, labels=False, border=True, keys=None):
"""
Initialize horizontal bar chart renderer.
Parameters:
- height (int): Chart height
- width (int): Chart width
- functions (dict): Dictionary mapping data series names to value lists
- colour (int): Default chart color
- bg (int): Background color
- gradient (list): Color gradient for bars
- scale (float): Scale factor for values
- axes (bool): Whether to draw axes
- intervals (float): Interval for axis labels
- labels (bool): Whether to show value labels
- border (bool): Whether to draw chart border
- keys (list): List of data series to display
"""
class VBarChart(StaticRenderer):
"""Vertical bar chart renderer"""
def __init__(self, height, width, functions, colour=7, bg=0, gradient=None, scale=None, axes=True, intervals=None, labels=False, border=True, keys=None):
"""
Initialize vertical bar chart renderer.
Parameters:
- height (int): Chart height
- width (int): Chart width
- functions (dict): Dictionary mapping data series names to value lists
- colour (int): Default chart color
- bg (int): Background color
- gradient (list): Color gradient for bars
- scale (float): Scale factor for values
- axes (bool): Whether to draw axes
- intervals (float): Interval for axis labels
- labels (bool): Whether to show value labels
- border (bool): Whether to draw chart border
- keys (list): List of data series to display
"""Renderers for displaying and processing image files in text mode.
class ImageFile(StaticRenderer):
"""Static image file renderer with ASCII conversion"""
def __init__(self, file_name, height=None, colours=8, bg=0, fill_background=False, unicode_char=" "):
"""
Initialize image file renderer.
Parameters:
- file_name (str): Path to image file (JPEG, PNG, GIF supported)
- height (int): Target height (None = preserve aspect ratio)
- colours (int): Number of colors to use (8 or 256)
- bg (int): Background color
- fill_background (bool): Whether to fill background
- unicode_char (str): Unicode character to use for pixels
"""
class ColourImageFile(StaticRenderer):
"""Color image file renderer with full color support"""
def __init__(self, screen, file_name, height=None, uni=False, dither=False):
"""
Initialize color image renderer.
Parameters:
- screen (Screen): Target screen for color capabilities
- file_name (str): Path to image file
- height (int): Target height (None = preserve aspect ratio)
- uni (bool): Whether to use unicode characters
- dither (bool): Whether to apply dithering
"""Animated renderers for creating dynamic visual effects and patterns.
class Fire(DynamicRenderer):
"""Fire animation effect renderer"""
def __init__(self, height, width, emitter, colour, bg, start_frame=0):
"""
Initialize fire effect renderer.
Parameters:
- height (int): Fire effect height
- width (int): Fire effect width
- emitter (str): Fire source pattern string
- colour (int): Fire color scheme
- bg (int): Background color
- start_frame (int): Starting animation frame
"""
class Plasma(DynamicRenderer):
"""Plasma effect renderer with flowing patterns"""
def __init__(self, height, width, colours):
"""
Initialize plasma effect renderer.
Parameters:
- height (int): Effect height
- width (int): Effect width
- colours (int): Number of colors in plasma effect
"""
class Kaleidoscope(DynamicRenderer):
"""Kaleidoscope pattern renderer with rotating symmetry"""
def __init__(self, height, width, renderers, pattern):
"""
Initialize kaleidoscope renderer.
Parameters:
- height (int): Effect height
- width (int): Effect width
- renderers (list): List of source renderers to transform
- pattern (str): Symmetry pattern for kaleidoscope
"""
class RotatedDuplicate(DynamicRenderer):
"""Rotated duplicate pattern renderer"""
def __init__(self, screen, renderer, angle=None):
"""
Initialize rotated duplicate renderer.
Parameters:
- screen (Screen): Target screen
- renderer (Renderer): Source renderer to rotate/duplicate
- angle (float): Rotation angle (None = auto-rotate)
"""Specialized renderers for playing back various media formats in text mode.
class AbstractScreenPlayer(StaticRenderer):
"""Abstract base class for media playback renderers"""
def __init__(self):
"""Initialize media player renderer"""
def play(self, screen, scene, stop_on_resize=False):
"""
Play media on screen.
Parameters:
- screen (Screen): Target screen
- scene (Scene): Scene containing player effect
- stop_on_resize (bool): Whether to stop on terminal resize
"""
class AnsiArtPlayer(AbstractScreenPlayer):
"""ANSI art file player renderer"""
def __init__(self, filename):
"""
Initialize ANSI art player.
Parameters:
- filename (str): Path to ANSI art file (.ans, .asc)
"""
class AsciinemaPlayer(AbstractScreenPlayer):
"""Asciinema recording player renderer"""
def __init__(self, filename):
"""
Initialize asciinema player.
Parameters:
- filename (str): Path to asciinema recording file (.cast)
"""from asciimatics.screen import ManagedScreen
from asciimatics.scene import Scene
from asciimatics.effects import Print
from asciimatics.renderers import FigletText
def figlet_demo(screen):
effects = [
Print(screen,
FigletText("HELLO", font='big'),
screen.height // 2 - 4,
colour=Screen.COLOUR_GREEN),
Print(screen,
FigletText("WORLD", font='slant'),
screen.height // 2 + 1,
colour=Screen.COLOUR_YELLOW)
]
screen.play([Scene(effects, 300)])
ManagedScreen(figlet_demo).run()from asciimatics.renderers import SpeechBubble
from asciimatics.effects import Print
def speech_demo(screen):
bubble = SpeechBubble("Hello! This is a speech bubble with a tail.", tail='L')
effects = [
Print(screen, bubble, 5, 10)
]
screen.play([Scene(effects, 200)])
ManagedScreen(speech_demo).run()from asciimatics.renderers import BarChart
from asciimatics.effects import Print
def chart_demo(screen):
# Sample data
data = {
"Sales": [20, 30, 25, 40, 35],
"Costs": [15, 20, 18, 25, 22]
}
chart = BarChart(
height=10,
width=60,
functions=data,
colour=Screen.COLOUR_GREEN,
axes=True,
labels=True,
border=True
)
effects = [
Print(screen, chart, 2, 5)
]
screen.play([Scene(effects, 500)])
ManagedScreen(chart_demo).run()from asciimatics.renderers import ImageFile
from asciimatics.effects import Print
def image_demo(screen):
# Display image file as ASCII art
image = ImageFile(
"example.jpg",
height=20,
colours=256,
fill_background=True
)
effects = [
Print(screen, image, 2, 2)
]
screen.play([Scene(effects, 300)])
ManagedScreen(image_demo).run()from asciimatics.renderers import Fire
from asciimatics.effects import Print
def fire_demo(screen):
# Create fire effect
fire = Fire(
height=15,
width=40,
emitter="*" * 40, # Fire source pattern
colour=Screen.COLOUR_RED,
bg=Screen.COLOUR_BLACK
)
effects = [
Print(screen, fire, screen.height - 17,
(screen.width - 40) // 2)
]
screen.play([Scene(effects, -1)]) # Infinite duration
ManagedScreen(fire_demo).run()from asciimatics.renderers import Plasma
from asciimatics.effects import Print
def plasma_demo(screen):
plasma = Plasma(
height=screen.height,
width=screen.width,
colours=256
)
effects = [
Print(screen, plasma, 0, 0)
]
screen.play([Scene(effects, -1)])
ManagedScreen(plasma_demo).run()from asciimatics.renderers import FigletText, Box, Rainbow
from asciimatics.effects import Print
def multi_renderer_demo(screen):
effects = [
# Box border
Print(screen,
Box(60, 10, uni=True),
5, 10,
colour=Screen.COLOUR_BLUE),
# Title with rainbow effect
Print(screen,
Rainbow(screen, 0, 0, "*** DEMO ***"),
7, 25,
colour=Screen.COLOUR_WHITE),
# ASCII art text
Print(screen,
FigletText("COOL", font='small'),
10, 20,
colour=Screen.COLOUR_GREEN)
]
screen.play([Scene(effects, 400)])
ManagedScreen(multi_renderer_demo).run()from asciimatics.renderers import StaticRenderer
class CustomPattern(StaticRenderer):
"""Custom pattern renderer example"""
def __init__(self, width, height, pattern_char="*"):
super().__init__()
self._width = width
self._height = height
self._pattern_char = pattern_char
def render(self, frame):
# Create checkerboard pattern
lines = []
for y in range(self._height):
line = ""
for x in range(self._width):
if (x + y) % 2 == 0:
line += self._pattern_char
else:
line += " "
lines.append(line)
return lines
@property
def max_height(self):
return self._height
@property
def max_width(self):
return self._width
# Usage
def custom_demo(screen):
custom = CustomPattern(20, 10, "#")
effects = [
Print(screen, custom, 5, 10, colour=Screen.COLOUR_CYAN)
]
screen.play([Scene(effects, 200)])
ManagedScreen(custom_demo).run()