lookatme¶
lookatme is an interactive, terminal-based markdown presentation tool that
supports:
- Themes
- Syntax highlighting
- Styling and settings embedded within the Markdown YAML header
- Embedded terminals as part of a presentation
- Live and manual source reloading
- Contrib extensions
- Smart Slide Splitting
Tour¶
TL;DR Getting Started¶
Install lookatme with:
pip install lookatme
Run lookatme on slides written in Markdown:
lookatme slides.md
Slides are separated with --- hrules:
# Slide 1
Some text
---
# Slide 2
More text
A basic, optional YAML header may be included at the top of the slides:
---
title: Slides Presentation
author: Me Not You
date: 2019-12-02
---
# Slide 1
Some text
Slides can be progressively rendered by adding <!-- stop --> comments
between block elements (paragraphs, tables, lists, etc.):
# Progressive Slide
<!-- stop -->
Paragraph 1
<!-- stop -->
Paragraph 2
<!-- stop -->
Paragraph 3
Getting Started¶
Usage¶
The lookatme CLI has a few options to control it’s behavior:
{{LOOKATME_HELP_OUTPUT_INDENTED}}
--live / --live-reload¶
This flag turns on live reloading within lookatme. If the input markdown is a filepath (and not stdin), the filepath with be watched for changes to its modification time. If a change to the file’s modification time is observed, the slide deck is re-read and rendered, keeping the current slide in focus.
If your editor supports saving with every keystroke, instant slide updates are possible:
-e EXT_NAME1,EXT_NAME2 / --exts EXT_NAME1,EXT_NAME2¶
Allows a comma-separated list of extension names to be pre-loaded into lookatme without requring them to be declared in the Markdown source.
-s / --safe¶
Do NOT load any new extensions specified in the markdown (ignore them). New
extensions are extensions that have not manually been allowed via the -e
argument or the LOOKATME_EXTS environment variable.
--no-ext-warn¶
Do not warn about new extensions that are to-be-loaded that are specified in
the source markdown. New extensions are extensions that have not manually been
allowed via the -e argument or the LOOKATME_EXTS environment variable.
-i¶
Ignore failure loading extensions. This does not ignore warnings, but ignores
any hard-errors during import, such as ImportError.
--single / --one¶
Render the markdown source as a single slide, ignoring all hrules. Scroll overflowing slides with the up/down arrow keys and page up/page down.
--debug and --log¶
Turns on debug logging for lookatme. The debug log will be created in your platform’s
temporary directory by default and will be named lookatme.log:
$> lookatme slides.md --debug
# in another terminal
$> tail -f /tmp/lookatme.log
DEBUG:lookatme.RENDER: Rendering token {'type': 'heading', 'level': 2, 'text': 'TOC'}
DEBUG:lookatme.RENDER: Rendering token {'type': 'list_start', 'ordered': False}
DEBUG:lookatme.RENDER: Rendering token {'type': 'list_item_start'}
DEBUG:lookatme.RENDER: Rendering token {'type': 'text', 'text': '[Features](#features)'}
DEBUG:lookatme.RENDER: Rendering token {'type': 'list_start', 'ordered': False}
DEBUG:lookatme.RENDER: Rendering token {'type': 'list_item_start'}
You may set a custom log location with the --log flag
--theme¶
Themes in lookatme are pre-defined stylings. Lookatme comes with two built-in
themes: dark and light. These themes are intended to look good on
dark terminals and light terminals.
See the Dark Theme and Light Theme pages for more details. See the Style Precedence page for details on the order style overrides and settings are applied.
--style¶
This option overrides the Pygments syntax highlighting style to use. See the Style Precedence for details about style overriding order.
At the time of this writing, available Pygments style options include:
- default
- emacs
- friendly
- colorful
- autumn
- murphy
- manni
- monokai
- perldoc
- pastie
- borland
- trac
- native
- fruity
- bw
- vim
- vs
- tango
- rrt
- xcode
- igor
- paraiso-light
- paraiso-dark
- lovelace
- algol
- algol_nu
- arduino
- rainbow_dash
- abap
- solarized-dark
- solarized-light
- sas
- stata
- stata-light
- stata-dark
--dump-styles¶
Print the final, resolved style definition that will be used to render the markdown as currently specified on the command-line. See the Style Precedence section for details on how this works.
E.g.:
lookatme examples/tour.md -theme --style solarized-dark --dump-styles
Slides¶
Slides in lookatme are:
- Separated by hrule elements:
---in Markdown- Resized to fit the current window
Metadata¶
Slide metadata is contained within an optional YAML header:
---
title: TITLE
author: AUTHOR
date: 2019-12-02
extensions: []
styles: {}
---
Additional, unknown metadata fields are allowed at the top level. However, the
styles field and subfields are strictly validated.
Extensions¶
Extensions are lookatme contrib modules that redefine lookatme behavior. E.g.,
the lookatmecontrib.calendar example in the
examples folder
redefines the render_code function found in lookatme/render/markdown_block.py.
The original render_code function gives contrib extensions first-chance at
handling any function calls. Contrib extensions are able to ignore function
calls, and thus allow the default lookatme behavior, by raising the
IgnoredByContrib exception:
import datetime
import calendar
import urwid
from lookatme.exceptions import IgnoredByContrib
def render_code(token, body, stack, loop):
lang = token["lang"] or ""
if lang != "calendar":
raise IgnoredByContrib()
today = datetime.datetime.utcnow()
return urwid.Text(calendar.month(today.year, today.month))
Styles¶
In addition to the --style and --theme CLI options for lookatme, the
slide metadata may explicitly override styling behaviors within lookatme:
---
title: TITLE
author: AUTHOR
date: 2019-12-02
styles:
style: monokai
table:
column_spacing: 3
header_divider: "-"
---
# Slide 1
text
The final, resolved styling settings that will be used when displaying a
markdown source is viewable by adding the --dump-styles flag as a command-line
argument.
See the Default Style Settings for a full list of available, overrideable styles.
Style Precedence¶
Styling may be set in three locations in lookatme:
- In a theme
- In a slide’s YAML header
- On the command-line
When constructing the final, resolved style set that will be used to render
markdown, lookatme starts with the default style settings defined in
lookatme.schemas, and then applies overrides in the order specified
above.
Overrides are applied by performing a deep merge of nested dictionaries. For example, if the default styles defined in schemas.py were:
headings:
"1":
fg: "#33c,bold"
bg: "default"
"2":
fg: "#222,bold"
bg: "default"
… and if the style overrides defined by a theme were:
headings:
"1":
bg: "#f00"
… and if the style overrides defined in the slide YAML header were:
headings:
"2":
fg: "#f00,bold,underline"
The final, resolved style settings for rendering the markdown would be:
headings:
"1":
fg: "#33c,bold"
bg: "#f00" # from the theme
"2":
fg: "#f00,bold,underline" # from the slide YAML header
bg: "default"
Default Style Settings¶
The default styles and formats are defined in the marshmallow schemas in
lookatme.schemas. The dark theme is an empty theme with no overrides
(the defaults are the dark theme):
author:
bg: default
fg: '#f30'
bullets:
'1': •
'2': ⁃
'3': ◦
default: •
date:
bg: default
fg: '#777'
headings:
'1':
bg: default
fg: '#9fc,bold'
prefix: '██ '
suffix: ''
'2':
bg: default
fg: '#1cc,bold'
prefix: '▓▓▓ '
suffix: ''
'3':
bg: default
fg: '#29c,bold'
prefix: '▒▒▒▒ '
suffix: ''
'4':
bg: default
fg: '#559,bold'
prefix: '░░░░░ '
suffix: ''
default:
bg: default
fg: '#346,bold'
prefix: '░░░░░ '
suffix: ''
hrule:
char: ─
style:
bg: default
fg: '#777'
link:
bg: default
fg: '#33c,underline'
margin:
bottom: 0
left: 2
right: 2
top: 0
numbering:
'1': numeric
'2': alpha
'3': roman
default: numeric
padding:
bottom: 0
left: 10
right: 10
top: 0
quote:
bottom_corner: └
side: ╎
style:
bg: default
fg: italics,#aaa
top_corner: ┌
slides:
bg: default
fg: '#f30'
style: monokai
table:
column_spacing: 3
header_divider: ─
title:
bg: default
fg: '#f30,bold,italics'
Contrib Extensions¶
lookatme allows an extension to override and redefine how markdown is rendered. Extensions have first-chance opportunities to handle rendering function calls. Extensions also have the ability to ignore specific rendering function calls and allow original lookatme behavior (or other extensions) to handle the call to that rendering function.
For example, an extension may provide its own implementation of the render
function render_table to provide custom table rendering, such as sortable
rows, alternating row background colors, etc.
Using Extensions¶
Extensions are namespace packages within lookatme.contrib. The are used by
- Installing the extension with
pip install lookatme.contrib.XXX- Adding the extension to the list of extensions required by your slides:
---
title: TITLE
author: AUTHOR
date: 2019-11-01
extensions:
- XXX
---
# Slide 1
...
Extension Layout¶
It is highly recommended that you use the lookatme.contrib-template to create new extensions.
Extensions must be a namespaced module within the lookatme.contrib
submodule. The basic tree layout for such an extension is below:
examples/calendar_contrib/
├── lookatme
│ └── contrib
│ └── calendar.py
└── setup.py
Notice that there is not an __init__.py file in the contrib path. This is
using the implicit namespace package
format for creating namespace packages, where an __init__.py is not
needed.
Extension setup.py¶
Below is the setup.py from the examples/calendar_contrib extension:
"""
Setup for lookatme.contrib.calender example
"""
from setuptools import setup, find_namespace_packages
import os
setup(
name="lookatme.contrib.calendar",
version="0.0.0",
description="Adds a calendar code block type",
author="James Johnson",
author_email="d0c.s4vage@gmail.com",
python_requires=">=3.5",
packages=find_namespace_packages(include=["lookatme.*"]),
)
Overriding Behavior¶
Any function within lookatme that is decorated with @contrib_first may be
overridden by an extension by defining a function of the same name within the
extension module.
For example, to override the render_code function that is declared in
lookatme in lookatme/render/markdown_block.py,
the example calender extension must declare its own function named
render_code that accepts the same arguments and provides the same return
values as the original function:
"""
Defines a calendar extension that overrides code block rendering if the
language type is calendar
"""
import datetime
import calendar
import urwid
from lookatme.exceptions import IgnoredByContrib
def user_warnings():
"""No warnings exist for this extension. Anything you want to warn the
user about, such as security risks in processing untrusted markdown, should
go here.
"""
return []
def render_code(token, body, stack, loop):
lang = token["lang"] or ""
if lang != "calendar":
raise IgnoredByContrib()
today = datetime.datetime.utcnow()
return urwid.Text(calendar.month(today.year, today.month))
Notice how the extension code above raises the IgnoredByContrib exception
to allow the default lookatme behavior to occur.
Overrideable Functions¶
Below is an automatically generated list of all overrideable functions that
are present in this release of lookatme. See the
lookatme.tui.SlideRenderer.do_render function for details on markdown_block
render function arguments and return values.
render_paragraph_openrender_paragraph_closerender_inlinerender_ordered_list_openrender_bullet_list_openrender_list_openrender_ordered_list_closerender_bullet_list_closerender_list_closerender_list_item_openrender_list_item_closerender_heading_openrender_heading_closerender_blockquote_openrender_blockquote_closerender_fencerender_code_blockrender_table_openrender_hrrender_textrender_em_openrender_em_closerender_strong_openrender_strong_closerender_s_openrender_s_closerender_link_openrender_link_closerender_imagerender_image_closerender_hardbreakrender_softbreakrender_code_inlinerender_html_inlinerender_html_tag_default_openrender_html_tag_default_closerender_html_tag_u_openrender_html_tag_i_openrender_html_tag_b_openrender_html_tag_em_openrender_html_tag_blink_openrender_html_tag_br_openrender_html_tag_div_openrender_html_tag_div_closerender_html_tag_ol_openrender_html_tag_ol_closerender_html_tag_ul_openrender_html_tag_ul_closerender_html_tag_li_openrender_html_tag_li_closeroot_urwid_widget
Smart Slide Splitting¶
lookatme will automatically split input markdown into separate slides if no
hrules are present in the input markdown.
Slides are split automatically in two ways
- If the lowest (e.g. h1 < h2) heading occurs only once, that heading is used as the title for the presentation. The next lowest heading will be used as the slide separator marker.
- If the lowest (e.g. h1 < h2) heading occurs multiple times, that heading will be used as the slide separator marker and the heading will not be set.
E.g., below is the README.md of lookatme:
Builtin Extensions¶
lookatme comes with a few built-in extensions.
Builtin Extension Qualification¶
Builtin extensions must:
- Not require extra dependencies just for the extension
- Be generally useful in most cases
E.g., the qrcode extension has an extra dependency. This immediately disqualifies it from being a builtin extension.
Usage¶
Although builtin extensions are defined in the same way as external Contrib Extensions, builtin extensions do not need to be explicitly declared in the YAML header.
List of Builtin Extensions¶
Terminal Extension¶
The lookatme.contrib.terminal builtin extension allows terminals to be
embedded within slides.
Basic Format¶
The terminal extension modifies the code block markdown rendering by intercepting
code blocks whose language has the format terminal\d+. The number following
the terminal string indicates how many rows the terminal should use when
rendered (the height).
E.g.
```terminal8
bash -il
```
The content of the code block is the command to be run in the terminal. Clicking inside of the terminal gives the terminal focus, which will allow you to interact with it, type in it, etc.
To escape from the terminal, press ctrl+a.
Extended Format¶
The terminal extension also has a terminal-ex mode that can be used as the
language in a code block. When terminal-ex is used, the contents of the code
block must be YAML that conforms to the TerminalExSchema schema.
The default schema is shown below:
command: "the command to run" # required
rows: 10 # number of rows for the terminal (height)
init_text: null # initial text to feed to the command. This is
# useful to, e.g., pre-load text on a
# bash prompt so that only "enter" must be
# pressed. Uses the `expect` command.
init_wait: null # the prompt (string) to wait for with `expect`
# this is required if init_text is set.
init_codeblock: true # show a codeblock with the init_text as its
# content
init_codeblock_lang: text # the language of the init codeblock
E.g.
```terminal-ex
command: bash -il
rows: 20
init_text: echo hello
init_wait: '$> '
init_codeblock_lang: bash
```
File Loader Extension¶
The lookatme.contrib.file_loader builtin extension allows external
files to be sourced into the code block, optionally being transformed and
optionally restricting the range of lines to display.
Format¶
The file loader extension modifies the code block markdown rendering by intercepting
code blocks whose language equals file. The contents of the code block must
be YAML that conforms to the FileSchema schema.
The default schema is shown below:
path: path/to/the/file # required
relative: true # relative to the slide source directory
lang: text # pygments language to render in the code block
transform: null # optional shell command to transform the file data
lines:
start: 0
end: null
Note
The line range is only applied AFTER transformations are performed on the file data.
lookatme¶
lookatme package¶
Subpackages¶
lookatme.contrib package¶
This module defines a built-in contrib module that enables external files to be included within the slide. This is extremely useful when having source code displayed in a code block, and then running/doing something with the source data in a terminal on the same slide.
-
class
lookatme.contrib.file_loader.FileSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.Schema-
class
Meta[source]¶ Bases:
object-
render_module¶ alias of
YamlRender
-
-
load(*args, **kwargs) → Dict[KT, VT][source]¶ Deserialize a data structure to an object defined by this Schema’s fields.
Parameters: - data – The data to deserialize.
- many – Whether to deserialize data as a collection. If None, the value for self.many is used.
- partial – Whether to ignore missing fields and not require
any fields declared. Propagates down to
Nestedfields as well. If its value is an iterable, only missing fields listed in that iterable will be ignored. Use dot delimiters to specify nested fields. - unknown – Whether to exclude, include, or raise an error for unknown fields in the data. Use EXCLUDE, INCLUDE or RAISE. If None, the value for self.unknown is used.
Returns: Deserialized data
New in version 1.0.0.
Changed in version 3.0.0b7: This method returns the deserialized data rather than a
(data, errors)duple. AValidationErroris raised if invalid data are passed.
-
loads(*args, **kwargs) → Dict[KT, VT][source]¶ Same as
load(), except it takes a JSON string as input.Parameters: - json_data – A JSON string of the data to deserialize.
- many – Whether to deserialize obj as a collection. If None, the value for self.many is used.
- partial – Whether to ignore missing fields and not require
any fields declared. Propagates down to
Nestedfields as well. If its value is an iterable, only missing fields listed in that iterable will be ignored. Use dot delimiters to specify nested fields. - unknown – Whether to exclude, include, or raise an error for unknown fields in the data. Use EXCLUDE, INCLUDE or RAISE. If None, the value for self.unknown is used.
Returns: Deserialized data
New in version 1.0.0.
Changed in version 3.0.0b7: This method returns the deserialized data rather than a
(data, errors)duple. AValidationErroris raised if invalid data are passed.
-
opts= <marshmallow.schema.SchemaOpts object>¶
-
class
-
class
lookatme.contrib.file_loader.LineRange(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.Schema-
opts= <marshmallow.schema.SchemaOpts object>¶
-
-
lookatme.contrib.file_loader.render_fence(token: Dict[KT, VT], ctx: lookatme.render.context.Context)[source]¶ Render the code, ignoring all code blocks except ones with the language set to
file.
This module defines a built-in contrib module that enables terminal embedding within a slide.
-
class
lookatme.contrib.terminal.TerminalExSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.SchemaThe schema used for
terminal-excode blocks.-
class
Meta[source]¶ Bases:
object-
render_module¶ alias of
YamlRender
-
-
load(*args, **kwargs) → Dict[KT, VT][source]¶ Deserialize a data structure to an object defined by this Schema’s fields.
Parameters: - data – The data to deserialize.
- many – Whether to deserialize data as a collection. If None, the value for self.many is used.
- partial – Whether to ignore missing fields and not require
any fields declared. Propagates down to
Nestedfields as well. If its value is an iterable, only missing fields listed in that iterable will be ignored. Use dot delimiters to specify nested fields. - unknown – Whether to exclude, include, or raise an error for unknown fields in the data. Use EXCLUDE, INCLUDE or RAISE. If None, the value for self.unknown is used.
Returns: Deserialized data
New in version 1.0.0.
Changed in version 3.0.0b7: This method returns the deserialized data rather than a
(data, errors)duple. AValidationErroris raised if invalid data are passed.
-
loads(*args, **kwargs) → Dict[KT, VT][source]¶ Same as
load(), except it takes a JSON string as input.Parameters: - json_data – A JSON string of the data to deserialize.
- many – Whether to deserialize obj as a collection. If None, the value for self.many is used.
- partial – Whether to ignore missing fields and not require
any fields declared. Propagates down to
Nestedfields as well. If its value is an iterable, only missing fields listed in that iterable will be ignored. Use dot delimiters to specify nested fields. - unknown – Whether to exclude, include, or raise an error for unknown fields in the data. Use EXCLUDE, INCLUDE or RAISE. If None, the value for self.unknown is used.
Returns: Deserialized data
New in version 1.0.0.
Changed in version 3.0.0b7: This method returns the deserialized data rather than a
(data, errors)duple. AValidationErroris raised if invalid data are passed.
-
opts= <marshmallow.schema.SchemaOpts object>¶
-
class
This module handles loading and using lookatme_contrib modules
- def loads(self, *args, **kwargs) -> Dict:
res = super(self.__class__, self).loads(*args, **kwargs) if res is None:
raise ValueError(“Could not loads”)return res
- def load(self, *args, **kwargs) -> Dict:
res = super(self.__class__, self).load(*args, **kwargs) if res is None:
raise ValueError(“Could not load”)return res
Contrib modules are directly used
-
lookatme.contrib.contrib_first(fn)[source]¶ A decorator that allows contrib modules to override default behavior of lookatme. E.g., a contrib module may override how a table is displayed to enable sorting, or enable displaying images rendered with ANSII color codes and box drawing characters, etc.
Contrib modules may ignore chances to override default behavior by raising the
lookatme.contrib.IgnoredByContribexception.
-
lookatme.contrib.load_contribs(contrib_names, safe_contribs, ignore_load_failure=False)[source]¶ Load all contrib modules specified by
contrib_names. These should all be namespaced packages under thelookatmecontribnamespace. E.g.lookatmecontrib.calendarwould be an extension provided by a contrib module, and would be added to anextensionslist in a slide’s YAML header ascalendar.safe_contribsis a set of contrib names that are manually provided by the user by the-eflag or env variable of extensions to auto-load.
lookatme.output package¶
Base module for lookatme output formats
-
class
lookatme.output.base.BaseOutputFormat[source]¶ Bases:
object-
DEFAULT_OPTIONS= {}¶
-
NAME= None¶
-
REQUIRED_BINARIES= []¶
-
do_format_pres(pres: lookatme.pres.Presentation, output_path: str)[source]¶ Perform the action of outputting the presentation to this specific output format.
-
format_pres(pres: lookatme.pres.Presentation, output_path: str, options: Dict[KT, VT])[source]¶ Perform the action of outputting the presentation to this specific output format.
-
Output an entire slide deck into an interactive html file
Output formatter for raw “screenshots” of lookatme as it would appear in a terminal
-
class
lookatme.output.html_raw.HtmlRawScreenshotOutputFormat[source]¶ Bases:
lookatme.output.base.BaseOutputFormat-
DEFAULT_OPTIONS= {'cols': 100, 'delay_default': 1000, 'delay_scroll': 100, 'keys': ['show-all'], 'render_images': False, 'rows': 30}¶
-
NAME= 'html_raw'¶
-
lookatme.render package¶
Replaces an urwid.BaseScreen with one that renders the terminal into html files.
-
class
lookatme.render.context.ContainerInfo(container: 'urwid.Widget', meta: 'Dict[str, Any]', source_token: 'Optional[Dict]')[source]¶ Bases:
object
-
class
lookatme.render.context.Context(loop: Optional[urwid.main_loop.MainLoop])[source]¶ Bases:
object-
clean_state_validate()[source]¶ Validate that all stacks are empty, that everything unwound correctly
-
clone() → lookatme.render.context.Context[source]¶ Create a new limited clone of the current context.
The only data that is actually cloned is the source and spec stacks.
-
container¶ Return the current container
-
container_pop() → lookatme.render.context.ContainerInfo[source]¶ Pop the last element off the stack. Returns the popped widget
-
container_push(new_item: urwid.widget.Widget, is_new_block: bool, custom_add: Optional[urwid.widget.Widget] = None)[source]¶ Push to the stack and propagate metadata
-
get_inline_markup()[source]¶ Return the current inline markup, ignoring any widgets that may have made it in
-
get_inline_widgets()[source]¶ Return the results of any inline rendering that has occurred in Widget form. The conversion here is necessary since inline rendering functions often produce urwid Text Markup instead of widgets, which need to be converted to ClickableText.
-
inline_markup_consumed¶ Return and clear the inline markup
-
inline_push(inline_result: Union[urwid.widget.Widget, str, Tuple[Optional[urwid.display_common.AttrSpec], str]])[source]¶ Push a new inline render result onto the stack. Either a widget, or text markup
-
inline_widgets_consumed¶ Return and clear the inline widgets
-
is_literal¶
-
meta¶ Return metadata associated with the current container, or None if the current container is None.
-
source¶ Return the current markdown source
-
source_get_token_lines(token: Dict[KT, VT], extra: int = 5, with_lines: bool = True, with_marker: bool = True) → List[str][source]¶
-
spec_general¶ Return the current fully resolved current AttrSpec
-
spec_text¶
-
spec_text_with(other_spec: Union[None, urwid.display_common.AttrSpec]) → urwid.display_common.AttrSpec[source]¶
-
tag¶
-
tag_push(new_tag: str, token: Dict[KT, VT], spec=None, text_only_spec=False)[source]¶ Push a new tag name onto the stack
-
tag_token¶
-
tokens¶ Return the current token iterator
-
unwind_bookmark¶
-
unwind_tokens¶ Generate a list of unwind (close) tokens from the token iterators in the stack
-
unwind_tokens_consumed¶ Generate a list of unwind (close) tokens from the token iterators in the stack
-
use_container(new_container: urwid.widget.Widget, is_new_block: bool, custom_add: Optional[urwid.widget.Widget] = None)[source]¶ Ensure that the container is pushed/popped correctly
-
use_container_tmp(new_container: urwid.widget.Widget)[source]¶ Swap out the entire container stack for a new one with the new container as the only item, while keeping spec and tag stacks
-
use_tokens(tokens, inline: bool = False)[source]¶ Create a context manager for pushing/popping tokens via a with block
-
Defines render functions that render lexed markdown block tokens into urwid representations
-
class
lookatme.render.markdown_block.FenceInfo(lang: str = 'text', line_numbers: bool = False, start_line_number: int = 1, hl_lines: List = <factory>, raw_attrs: Dict[str, str] = <factory>, raw_curly: str = '')[source]¶ Bases:
object-
lang= 'text'¶
-
line_numbers= False¶
-
raw_curly= ''¶
-
start_line_number= 1¶
-
-
class
lookatme.render.markdown_block.TableTokenExtractor[source]¶ Bases:
object-
curr_parent¶
-
curr_siblings¶
-
-
lookatme.render.markdown_block.parse_fence_info(info: str) → lookatme.render.markdown_block.FenceInfo[source]¶
-
lookatme.render.markdown_block.render(token, ctx: lookatme.render.context.Context)[source]¶ Render a single token
-
lookatme.render.markdown_block.render_all(ctx: lookatme.render.context.Context, and_unwind: bool = False)[source]¶
-
lookatme.render.markdown_block.render_blockquote_close(token: Dict[KT, VT], ctx: lookatme.render.context.Context)[source]¶
-
lookatme.render.markdown_block.render_blockquote_open(token: Dict[KT, VT], ctx: lookatme.render.context.Context)[source]¶
-
lookatme.render.markdown_block.render_bullet_list_close(token, ctx: lookatme.render.context.Context)[source]¶
-
lookatme.render.markdown_block.render_bullet_list_open(token, ctx: lookatme.render.context.Context)[source]¶
-
lookatme.render.markdown_block.render_code_block(token: Dict[KT, VT], ctx: lookatme.render.context.Context)[source]¶ Render a code_block - text that is indented four spaces.
-
lookatme.render.markdown_block.render_fence(token: Dict[KT, VT], ctx: lookatme.render.context.Context)[source]¶ Renders a code block using the Pygments library.
See
lookatme.tui.SlideRenderer.do_renderfor additional argument and return value descriptions.
-
lookatme.render.markdown_block.render_heading_close(token: Dict[KT, VT], ctx: lookatme.render.context.Context)[source]¶
-
lookatme.render.markdown_block.render_heading_open(token: Dict[KT, VT], ctx: lookatme.render.context.Context)[source]¶
-
lookatme.render.markdown_block.render_hr(token, ctx: lookatme.render.context.Context)[source]¶ Render a newline
See
lookatme.tui.SlideRenderer.do_renderfor argument and return value descriptions.
-
lookatme.render.markdown_block.render_list_item_close(_, ctx: lookatme.render.context.Context)[source]¶
-
lookatme.render.markdown_block.render_list_item_open(_, ctx: lookatme.render.context.Context)[source]¶
-
lookatme.render.markdown_block.render_list_open(token, ctx: lookatme.render.context.Context, ordered: bool)[source]¶
-
lookatme.render.markdown_block.render_ordered_list_close(token, ctx: lookatme.render.context.Context)[source]¶
-
lookatme.render.markdown_block.render_ordered_list_open(token, ctx: lookatme.render.context.Context)[source]¶
-
lookatme.render.markdown_block.render_paragraph_close(token, ctx: lookatme.render.context.Context)[source]¶
This module attempts to parse basic html
-
class
lookatme.render.markdown_html.Tag(tag_name: str, is_open: bool, attrs: Optional[Dict[str, str]] = None, style: Optional[Dict[str, str]] = None)[source]¶ Bases:
object
Defines render functions that work with mistune’s markdown inline lexer render interface
-
lookatme.render.markdown_inline.render(token, ctx: lookatme.render.context.Context)[source]¶ Render an inline token[“”] These tokens come from “children” tokens of a block token[“”]
-
lookatme.render.markdown_inline.render_all(ctx: lookatme.render.context.Context, and_unwind: bool = False)[source]¶
-
lookatme.render.markdown_inline.render_code_inline(token, ctx: lookatme.render.context.Context)[source]¶
-
lookatme.render.markdown_inline.render_html_inline(token, ctx: lookatme.render.context.Context)[source]¶
-
lookatme.render.markdown_inline.render_html_tag_b_open(token: Dict[KT, VT], tag: lookatme.render.markdown_html.Tag, ctx: lookatme.render.context.Context, style_spec: Optional[urwid.display_common.AttrSpec])[source]¶
-
lookatme.render.markdown_inline.render_html_tag_blink_open(token: Dict[KT, VT], tag: lookatme.render.markdown_html.Tag, ctx: lookatme.render.context.Context, style_spec: Optional[urwid.display_common.AttrSpec])[source]¶
-
lookatme.render.markdown_inline.render_html_tag_br_open(token: Dict[KT, VT], tag: lookatme.render.markdown_html.Tag, ctx: lookatme.render.context.Context, style_spec: Optional[urwid.display_common.AttrSpec])[source]¶
-
lookatme.render.markdown_inline.render_html_tag_default_close(_, _tag: lookatme.render.markdown_html.Tag, ctx: lookatme.render.context.Context, _style_spec: Optional[urwid.display_common.AttrSpec])[source]¶
-
lookatme.render.markdown_inline.render_html_tag_default_open(token: Dict[KT, VT], tag: lookatme.render.markdown_html.Tag, ctx: lookatme.render.context.Context, style_spec: Optional[urwid.display_common.AttrSpec])[source]¶
-
lookatme.render.markdown_inline.render_html_tag_div_close(_, tag: lookatme.render.markdown_html.Tag, ctx: lookatme.render.context.Context, style_spec: Optional[urwid.display_common.AttrSpec])[source]¶
-
lookatme.render.markdown_inline.render_html_tag_div_open(token: Dict[KT, VT], tag: lookatme.render.markdown_html.Tag, ctx: lookatme.render.context.Context, style_spec: Optional[urwid.display_common.AttrSpec])[source]¶
-
lookatme.render.markdown_inline.render_html_tag_em_open(token: Dict[KT, VT], tag: lookatme.render.markdown_html.Tag, ctx: lookatme.render.context.Context, style_spec: Optional[urwid.display_common.AttrSpec])[source]¶
-
lookatme.render.markdown_inline.render_html_tag_i_open(token: Dict[KT, VT], tag: lookatme.render.markdown_html.Tag, ctx: lookatme.render.context.Context, style_spec: Optional[urwid.display_common.AttrSpec])[source]¶
-
lookatme.render.markdown_inline.render_html_tag_li_close(token: Dict[KT, VT], tag: lookatme.render.markdown_html.Tag, ctx: lookatme.render.context.Context, style_spec: Optional[urwid.display_common.AttrSpec])[source]¶
-
lookatme.render.markdown_inline.render_html_tag_li_open(token: Dict[KT, VT], tag: lookatme.render.markdown_html.Tag, ctx: lookatme.render.context.Context, style_spec: Optional[urwid.display_common.AttrSpec])[source]¶
-
lookatme.render.markdown_inline.render_html_tag_ol_close(_, tag: lookatme.render.markdown_html.Tag, ctx: lookatme.render.context.Context, style_spec: Optional[urwid.display_common.AttrSpec])[source]¶
-
lookatme.render.markdown_inline.render_html_tag_ol_open(token: Dict[KT, VT], tag: lookatme.render.markdown_html.Tag, ctx: lookatme.render.context.Context, style_spec: Optional[urwid.display_common.AttrSpec])[source]¶
-
lookatme.render.markdown_inline.render_html_tag_u_open(token, tag: lookatme.render.markdown_html.Tag, ctx: lookatme.render.context.Context, style_spec: Optional[urwid.display_common.AttrSpec])[source]¶
-
lookatme.render.markdown_inline.render_html_tag_ul_close(_, tag: lookatme.render.markdown_html.Tag, ctx: lookatme.render.context.Context, style_spec: Optional[urwid.display_common.AttrSpec])[source]¶
-
lookatme.render.markdown_inline.render_html_tag_ul_open(token: Dict[KT, VT], tag: lookatme.render.markdown_html.Tag, ctx: lookatme.render.context.Context, style_spec: Optional[urwid.display_common.AttrSpec])[source]¶
-
lookatme.render.markdown_inline.render_image_close(token, ctx: lookatme.render.context.Context)[source]¶
-
lookatme.render.markdown_inline.render_link_open(token, ctx: lookatme.render.context.Context)[source]¶
-
lookatme.render.markdown_inline.render_strong_close(_, ctx: lookatme.render.context.Context)[source]¶
lookatme.utils package¶
-
lookatme.utils.can_style_item(item)[source]¶ Return true/false if
style_textcan work with the given item
-
lookatme.utils.core_widget(w) → urwid.widget.Widget[source]¶ Resolve a wrapped widget to its core widget value
-
lookatme.utils.dict_deep_update(to_update, new_vals)[source]¶ Deeply update the to_update dict with the new_vals
-
lookatme.utils.flatten_dict(tree_dict: Dict[KT, VT], flat_dict: Dict[KT, VT], prefixes: Optional[List[T]] = None)[source]¶
-
lookatme.utils.flatten_text(text, new_spec=None)[source]¶ Return a flattend list of tuples that can be used as the first argument to a new urwid.Text().
Parameters: - text (urwid.Text) – The text to flatten
- new_spec (SmartAttrSpec) – A new spec to merge with existing styles
Returns: list of tuples
-
lookatme.utils.overwrite_style(orig_style: Dict[str, str], new_style: Dict[str, str]) → Dict[str, str][source]¶
-
lookatme.utils.packed_widget_width(w: urwid.widget.Widget) → int[source]¶ Return the smallest size of the widget without wrapping
-
lookatme.utils.pile_or_listbox_add(container, widgets)[source]¶ Add the widget/widgets to the container
-
lookatme.utils.resolve_bag_of_text_markup_or_widgets(items)[source]¶ Resolve the list of items into either contiguous urwid.Text() instances, or pre-existing urwid.Widget objects
-
lookatme.utils.row_text(rendered_row)[source]¶ Return all text joined together from the rendered row
-
lookatme.utils.spec_from_stack(spec_stack: list, filter_fn=None) → urwid.display_common.AttrSpec[source]¶
lookatme.widgets package¶
This module contains code for ClickableText
-
class
lookatme.widgets.clickable_text.ClickableText(markup, *args, **kwargs)[source]¶ Bases:
urwid.widget.TextAllows clickable/changing text to be part of the Text() contents
-
signals= ['click', 'change']¶
-
-
class
lookatme.widgets.clickable_text.LinkIndicatorSpec(link_target, orig_spec, link_type: str = 'link')[source]¶ Bases:
lookatme.widgets.smart_attr_spec.SmartAttrSpecUsed to track a link within an urwid.Text instance
This module defines an urwid Widget that renders a codeblock
-
class
lookatme.widgets.codeblock.CodeBlock(source: str, lang: str = 'text', style_name: str = 'monokai', line_numbers: bool = False, start_line_number: int = 1, hl_lines: Optional[List[range]] = None, default_fg: Optional[str] = None, bg_override: Optional[str] = None)[source]¶ Bases:
urwid.container.Pile
-
class
lookatme.widgets.codeblock.StyleCache(default_fg: Optional[str] = None, bg_override: Optional[str] = None)[source]¶ Bases:
objectCaches the highlight styles for loaded pygments syntax highlighting styles.
-
get_style(style_name: str) → lookatme.widgets.codeblock.SyntaxHlStyle[source]¶ Return the highlight style for the specified pygments style name. If the style name isn’t found, the “text” style will be used instead.
-
-
class
lookatme.widgets.codeblock.SyntaxHlStyle(name: str, styles: Dict[str, lookatme.widgets.smart_attr_spec.SmartAttrSpec], pygments_style: pygments.style.StyleMeta, default_fg: str, bg_override: Optional[str] = None)[source]¶ Bases:
objectStores urwid styles for each token type for a specific pygments syntax highlighting style.
-
class
lookatme.widgets.fancy_box.FancyBox(w, tl_corner: str = '┌', tr_corner: str = '┐', bl_corner: str = '└', br_corner: str = '┘', tl_corner_spec: Optional[urwid.display_common.AttrSpec] = None, tr_corner_spec: Optional[urwid.display_common.AttrSpec] = None, bl_corner_spec: Optional[urwid.display_common.AttrSpec] = None, br_corner_spec: Optional[urwid.display_common.AttrSpec] = None, t_fill: str = '─', b_fill: str = '─', l_fill: str = '│', r_fill: str = '│', t_fill_spec: Optional[urwid.display_common.AttrSpec] = None, b_fill_spec: Optional[urwid.display_common.AttrSpec] = None, l_fill_spec: Optional[urwid.display_common.AttrSpec] = None, r_fill_spec: Optional[urwid.display_common.AttrSpec] = None, tight: bool = False)[source]¶ Bases:
urwid.decoration.WidgetDecoration,urwid.widget.WidgetWrapTest
-
b_fill= '─'¶
-
bl_corner= '│\n ┃\n ██━━──'¶
-
br_corner= '│\n ┃\n ──━━██'¶
-
l_fill= '│'¶
-
pack(size, focus=False)[source]¶ See
Widget.render()for parameter details.Returns: A “packed” size (maxcol, maxrow) for this widget Calculate and return a minimum size where all content could still be displayed. Fixed widgets must implement this method and return their size when
()is passed as the size parameter.This default implementation returns the size passed, or the maxcol passed and the value of
rows()as the maxrow when (maxcol,) is passed as the size parameter.Note
This is a new method that hasn’t been fully implemented across the standard widget types. In particular it has not yet been implemented for container widgets.
Textwidgets have implemented this method. You can useText.pack()to calculate the minimum columns and rows required to display a text widget without wrapping, or call it iteratively to calculate the minimum number of columns required to display the text wrapped into a target number of rows.
-
r_fill= '│'¶
-
set(tl_corner: Optional[str] = None, tr_corner: Optional[str] = None, bl_corner: Optional[str] = None, br_corner: Optional[str] = None, tl_corner_spec: Optional[urwid.display_common.AttrSpec] = None, tr_corner_spec: Optional[urwid.display_common.AttrSpec] = None, bl_corner_spec: Optional[urwid.display_common.AttrSpec] = None, br_corner_spec: Optional[urwid.display_common.AttrSpec] = None, t_fill: Optional[str] = None, b_fill: Optional[str] = None, l_fill: Optional[str] = None, r_fill: Optional[str] = None)[source]¶
-
t_fill= '─'¶
-
tl_corner= '██━━──\n ┃\n │'¶
-
tr_corner= '──━━██\n ┃\n │'¶
-
-
class
lookatme.widgets.line_fill.LineFill(beg_chars: str, fill_char: str, end_chars: str, beg_spec: Optional[urwid.display_common.AttrSpec] = None, fill_spec: Optional[urwid.display_common.AttrSpec] = None, end_spec: Optional[urwid.display_common.AttrSpec] = None, orientation: str = 'vertical')[source]¶ Bases:
urwid.widget.WidgetTest
-
HORIZONTAL= 'horizontal'¶
-
VERTICAL= 'vertical'¶
-
pack(size: Tuple, focus: bool = False)[source]¶ See
Widget.render()for parameter details.Returns: A “packed” size (maxcol, maxrow) for this widget Calculate and return a minimum size where all content could still be displayed. Fixed widgets must implement this method and return their size when
()is passed as the size parameter.This default implementation returns the size passed, or the maxcol passed and the value of
rows()as the maxrow when (maxcol,) is passed as the size parameter.Note
This is a new method that hasn’t been fully implemented across the standard widget types. In particular it has not yet been implemented for container widgets.
Textwidgets have implemented this method. You can useText.pack()to calculate the minimum columns and rows required to display a text widget without wrapping, or call it iteratively to calculate the minimum number of columns required to display the text wrapped into a target number of rows.
-
-
class
lookatme.widgets.scrollbar.Scrollbar(listbox: urwid.listbox.ListBox)[source]¶ Bases:
urwid.widget.WidgetA scrollbar that reflects the current scroll state of a list box. Non-selectable, non-interactive, informative only. Especially useful as an overlay or a box column so that you can have additional padding around your ListBox.
Defines a basic Table widget for urwid
-
class
lookatme.widgets.table.SortSetting[source]¶ Bases:
object-
ASCENDING= 1¶
-
DEFAULT= 0¶
-
DESCENDING= 2¶
-
-
class
lookatme.widgets.table.Table(ctx: lookatme.render.context.Context, header: Dict[KT, VT], body: Optional[Dict[KT, VT]])[source]¶ Bases:
urwid.container.Pile-
create_cells(rows, base_spec=None, header=False) → List[List[urwid.container.Pile]][source]¶ Create the rows for the body, optionally calling a modifier function on each created cell Text. The modifier must accept an urwid.Text object and must return an urwid.Text object.
-
gen_cells(row: List[urwid.container.Pile], row_specs: Tuple[urwid.display_common.AttrSpec, urwid.display_common.AttrSpec]) → List[Tuple[int, urwid.container.Pile]][source]¶
-
normalize_body()[source]¶ Normalize the cells in the body - truncate all cells that go beyond the number of headers, and add blank cells if we’re missing any
-
row_specs(row_idx: int, is_header: bool) → Tuple[urwid.display_common.AttrSpec, urwid.display_common.AttrSpec][source]¶ Return the row-specific specs (text and general) for the given row
-
signals= ['change']¶
-
validate_row(row: Dict[KT, VT])[source]¶ Validate that the provided row is a tr_open, with th_open or td_open children.
-
Submodules¶
lookatme.ascii_art module¶
Misc ASCII art
lookatme.config module¶
Config module for lookatme
lookatme.exceptions module¶
Exceptions used within lookatme
lookatme.log module¶
Logging module
lookatme.parser module¶
This module defines the parser for the markdown presentation file
-
class
lookatme.parser.Parser(single_slide=False)[source]¶ Bases:
objectA parser for markdown presentation files
-
parse(input_data) → Tuple[Dict[KT, VT], List[lookatme.slide.Slide], str][source]¶ Parse the provided input data into a Presentation object
Parameters: input_data (str) – The input markdown presentation to parse
-
lookatme.pres module¶
Defines Presentation specific objects
-
class
lookatme.pres.Presentation(input_stream: Optional[IO] = None, input_str: Optional[str] = None, theme: str = 'dark', live_reload=False, single_slide=False, preload_extensions=None, safe=False, no_ext_warn=False, ignore_ext_failure=False, no_threads=False)[source]¶ Bases:
objectDefines a presentation
-
get_slide_scroll_lines(width: int, height: int) → int[source]¶ Return the number of lines that need to be scrolled for each slide
-
reload(data=None)[source]¶ Reload this presentation
Parameters: data (str) – The data to render for this slide deck (optional)
-
lookatme.prompt module¶
Basic user-prompting helper functions
lookatme.schemas module¶
Defines all schemas used in lookatme
-
class
lookatme.schemas.BlockQuoteSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.Schema-
opts= <marshmallow.schema.SchemaOpts object>¶
-
-
class
lookatme.schemas.BorderBoxSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.Schema-
opts= <marshmallow.schema.SchemaOpts object>¶
-
-
class
lookatme.schemas.BulletsSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.Schema-
class
Meta[source]¶ Bases:
object-
include= {'1': <fields.Nested(dump_default={'text': '•', 'fg': 'bold', 'bg': ''}, attribute=None, validate=None, required=False, load_only=False, dump_only=False, load_default=<marshmallow.missing>, allow_none=False, error_messages={'required': 'Missing data for required field.', 'null': 'Field may not be null.', 'validator_failed': 'Invalid value.', 'type': 'Invalid type.'})>, '2': <fields.Nested(dump_default={'text': '‣', 'fg': 'bold', 'bg': ''}, attribute=None, validate=None, required=False, load_only=False, dump_only=False, load_default=<marshmallow.missing>, allow_none=False, error_messages={'required': 'Missing data for required field.', 'null': 'Field may not be null.', 'validator_failed': 'Invalid value.', 'type': 'Invalid type.'})>, '3': <fields.Nested(dump_default={'text': '◦', 'fg': 'bold', 'bg': ''}, attribute=None, validate=None, required=False, load_only=False, dump_only=False, load_default=<marshmallow.missing>, allow_none=False, error_messages={'required': 'Missing data for required field.', 'null': 'Field may not be null.', 'validator_failed': 'Invalid value.', 'type': 'Invalid type.'})>, '4': <fields.Nested(dump_default={'text': '•', 'fg': 'bold', 'bg': ''}, attribute=None, validate=None, required=False, load_only=False, dump_only=False, load_default=<marshmallow.missing>, allow_none=False, error_messages={'required': 'Missing data for required field.', 'null': 'Field may not be null.', 'validator_failed': 'Invalid value.', 'type': 'Invalid type.'})>, '5': <fields.Nested(dump_default={'text': '‣', 'fg': 'bold', 'bg': ''}, attribute=None, validate=None, required=False, load_only=False, dump_only=False, load_default=<marshmallow.missing>, allow_none=False, error_messages={'required': 'Missing data for required field.', 'null': 'Field may not be null.', 'validator_failed': 'Invalid value.', 'type': 'Invalid type.'})>, '6': <fields.Nested(dump_default={'text': '◦', 'fg': 'bold', 'bg': ''}, attribute=None, validate=None, required=False, load_only=False, dump_only=False, load_default=<marshmallow.missing>, allow_none=False, error_messages={'required': 'Missing data for required field.', 'null': 'Field may not be null.', 'validator_failed': 'Invalid value.', 'type': 'Invalid type.'})>}¶
-
-
opts= <marshmallow.schema.SchemaOpts object>¶
-
class
-
class
lookatme.schemas.CodeSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.Schema-
opts= <marshmallow.schema.SchemaOpts object>¶
-
-
class
lookatme.schemas.HeadingStyleSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.Schema-
opts= <marshmallow.schema.SchemaOpts object>¶
-
-
class
lookatme.schemas.HeadingsSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.Schema-
class
Meta[source]¶ Bases:
object-
include= {'1': <fields.Nested(dump_default={'fg': '#9fc,bold', 'bg': 'default', 'prefix': '██ ', 'suffix': ''}, attribute=None, validate=None, required=False, load_only=False, dump_only=False, load_default=<marshmallow.missing>, allow_none=False, error_messages={'required': 'Missing data for required field.', 'null': 'Field may not be null.', 'validator_failed': 'Invalid value.', 'type': 'Invalid type.'})>, '2': <fields.Nested(dump_default={'fg': '#1cc,bold', 'bg': 'default', 'prefix': '▓▓▓ ', 'suffix': ''}, attribute=None, validate=None, required=False, load_only=False, dump_only=False, load_default=<marshmallow.missing>, allow_none=False, error_messages={'required': 'Missing data for required field.', 'null': 'Field may not be null.', 'validator_failed': 'Invalid value.', 'type': 'Invalid type.'})>, '3': <fields.Nested(dump_default={'fg': '#29c,bold', 'bg': 'default', 'prefix': '▒▒▒▒ ', 'suffix': ''}, attribute=None, validate=None, required=False, load_only=False, dump_only=False, load_default=<marshmallow.missing>, allow_none=False, error_messages={'required': 'Missing data for required field.', 'null': 'Field may not be null.', 'validator_failed': 'Invalid value.', 'type': 'Invalid type.'})>, '4': <fields.Nested(dump_default={'fg': '#559,bold', 'bg': 'default', 'prefix': '░░░░░ ', 'suffix': ''}, attribute=None, validate=None, required=False, load_only=False, dump_only=False, load_default=<marshmallow.missing>, allow_none=False, error_messages={'required': 'Missing data for required field.', 'null': 'Field may not be null.', 'validator_failed': 'Invalid value.', 'type': 'Invalid type.'})>, '5': <fields.Nested(dump_default=<marshmallow.missing>, attribute=None, validate=None, required=False, load_only=False, dump_only=False, load_default=<marshmallow.missing>, allow_none=False, error_messages={'required': 'Missing data for required field.', 'null': 'Field may not be null.', 'validator_failed': 'Invalid value.', 'type': 'Invalid type.'})>, '6': <fields.Nested(dump_default=<marshmallow.missing>, attribute=None, validate=None, required=False, load_only=False, dump_only=False, load_default=<marshmallow.missing>, allow_none=False, error_messages={'required': 'Missing data for required field.', 'null': 'Field may not be null.', 'validator_failed': 'Invalid value.', 'type': 'Invalid type.'})>}¶
-
-
opts= <marshmallow.schema.SchemaOpts object>¶
-
class
-
class
lookatme.schemas.HruleSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
lookatme.schemas.TextStyleFieldSchema-
opts= <marshmallow.schema.SchemaOpts object>¶
-
-
class
lookatme.schemas.MetaSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.SchemaThe schema for presentation metadata
-
class
Meta[source]¶ Bases:
object-
render_module¶ alias of
YamlRender
-
unknown= 'include'¶
-
-
dump(*args, **kwargs) → Dict[KT, VT][source]¶ Serialize an object to native Python data types according to this Schema’s fields.
Parameters: - obj – The object to serialize.
- many – Whether to serialize obj as a collection. If None, the value for self.many is used.
Returns: Serialized data
New in version 1.0.0.
Changed in version 3.0.0b7: This method returns the serialized data rather than a
(data, errors)duple. AValidationErroris raised ifobjis invalid.Changed in version 3.0.0rc9: Validation no longer occurs upon serialization.
-
load(*args, **kwargs) → Dict[KT, VT][source]¶ Deserialize a data structure to an object defined by this Schema’s fields.
Parameters: - data – The data to deserialize.
- many – Whether to deserialize data as a collection. If None, the value for self.many is used.
- partial – Whether to ignore missing fields and not require
any fields declared. Propagates down to
Nestedfields as well. If its value is an iterable, only missing fields listed in that iterable will be ignored. Use dot delimiters to specify nested fields. - unknown – Whether to exclude, include, or raise an error for unknown fields in the data. Use EXCLUDE, INCLUDE or RAISE. If None, the value for self.unknown is used.
Returns: Deserialized data
New in version 1.0.0.
Changed in version 3.0.0b7: This method returns the deserialized data rather than a
(data, errors)duple. AValidationErroris raised if invalid data are passed.
-
loads(*args, **kwargs) → Dict[KT, VT][source]¶ Same as
load(), except it takes a JSON string as input.Parameters: - json_data – A JSON string of the data to deserialize.
- many – Whether to deserialize obj as a collection. If None, the value for self.many is used.
- partial – Whether to ignore missing fields and not require
any fields declared. Propagates down to
Nestedfields as well. If its value is an iterable, only missing fields listed in that iterable will be ignored. Use dot delimiters to specify nested fields. - unknown – Whether to exclude, include, or raise an error for unknown fields in the data. Use EXCLUDE, INCLUDE or RAISE. If None, the value for self.unknown is used.
Returns: Deserialized data
New in version 1.0.0.
Changed in version 3.0.0b7: This method returns the deserialized data rather than a
(data, errors)duple. AValidationErroris raised if invalid data are passed.
-
opts= <marshmallow.schema.SchemaOpts object>¶
-
class
-
class
lookatme.schemas.NoDatesSafeLoader(stream)[source]¶ Bases:
yaml.loader.SafeLoader-
classmethod
remove_implicit_resolver(tag_to_remove)[source]¶ Remove implicit resolvers for a particular tag
Takes care not to modify resolvers in super classes.
We want to load datetimes as strings, not dates, because we go on to serialise as json which doesn’t have the advanced types of yaml, and leads to incompatibilities down the track.
-
yaml_implicit_resolvers= {'': [('tag:yaml.org,2002:null', re.compile('^(?: ~\n |null|Null|NULL\n | )$', re.VERBOSE))], '!': [('tag:yaml.org,2002:yaml', re.compile('^(?:!|&|\\*)$'))], '&': [('tag:yaml.org,2002:yaml', re.compile('^(?:!|&|\\*)$'))], '*': [('tag:yaml.org,2002:yaml', re.compile('^(?:!|&|\\*)$'))], '+': [('tag:yaml.org,2002:float', re.compile('^(?:[-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+][0-9]+)?\n |\\.[0-9_]+(?:[eE][-+][0-9]+)?\n |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*\n |[-+, re.VERBOSE)), ('tag:yaml.org,2002:int', re.compile('^(?:[-+]?0b[0-1_]+\n |[-+]?0[0-7_]+\n |[-+]?(?:0|[1-9][0-9_]*)\n |[-+]?0x[0-9a-fA-F_]+\n |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9]), re.VERBOSE))], '-': [('tag:yaml.org,2002:float', re.compile('^(?:[-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+][0-9]+)?\n |\\.[0-9_]+(?:[eE][-+][0-9]+)?\n |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*\n |[-+, re.VERBOSE)), ('tag:yaml.org,2002:int', re.compile('^(?:[-+]?0b[0-1_]+\n |[-+]?0[0-7_]+\n |[-+]?(?:0|[1-9][0-9_]*)\n |[-+]?0x[0-9a-fA-F_]+\n |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9]), re.VERBOSE))], '.': [('tag:yaml.org,2002:float', re.compile('^(?:[-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+][0-9]+)?\n |\\.[0-9_]+(?:[eE][-+][0-9]+)?\n |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*\n |[-+, re.VERBOSE))], '0': [('tag:yaml.org,2002:float', re.compile('^(?:[-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+][0-9]+)?\n |\\.[0-9_]+(?:[eE][-+][0-9]+)?\n |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*\n |[-+, re.VERBOSE)), ('tag:yaml.org,2002:int', re.compile('^(?:[-+]?0b[0-1_]+\n |[-+]?0[0-7_]+\n |[-+]?(?:0|[1-9][0-9_]*)\n |[-+]?0x[0-9a-fA-F_]+\n |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9]), re.VERBOSE))], '1': [('tag:yaml.org,2002:float', re.compile('^(?:[-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+][0-9]+)?\n |\\.[0-9_]+(?:[eE][-+][0-9]+)?\n |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*\n |[-+, re.VERBOSE)), ('tag:yaml.org,2002:int', re.compile('^(?:[-+]?0b[0-1_]+\n |[-+]?0[0-7_]+\n |[-+]?(?:0|[1-9][0-9_]*)\n |[-+]?0x[0-9a-fA-F_]+\n |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9]), re.VERBOSE))], '2': [('tag:yaml.org,2002:float', re.compile('^(?:[-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+][0-9]+)?\n |\\.[0-9_]+(?:[eE][-+][0-9]+)?\n |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*\n |[-+, re.VERBOSE)), ('tag:yaml.org,2002:int', re.compile('^(?:[-+]?0b[0-1_]+\n |[-+]?0[0-7_]+\n |[-+]?(?:0|[1-9][0-9_]*)\n |[-+]?0x[0-9a-fA-F_]+\n |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9]), re.VERBOSE))], '3': [('tag:yaml.org,2002:float', re.compile('^(?:[-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+][0-9]+)?\n |\\.[0-9_]+(?:[eE][-+][0-9]+)?\n |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*\n |[-+, re.VERBOSE)), ('tag:yaml.org,2002:int', re.compile('^(?:[-+]?0b[0-1_]+\n |[-+]?0[0-7_]+\n |[-+]?(?:0|[1-9][0-9_]*)\n |[-+]?0x[0-9a-fA-F_]+\n |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9]), re.VERBOSE))], '4': [('tag:yaml.org,2002:float', re.compile('^(?:[-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+][0-9]+)?\n |\\.[0-9_]+(?:[eE][-+][0-9]+)?\n |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*\n |[-+, re.VERBOSE)), ('tag:yaml.org,2002:int', re.compile('^(?:[-+]?0b[0-1_]+\n |[-+]?0[0-7_]+\n |[-+]?(?:0|[1-9][0-9_]*)\n |[-+]?0x[0-9a-fA-F_]+\n |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9]), re.VERBOSE))], '5': [('tag:yaml.org,2002:float', re.compile('^(?:[-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+][0-9]+)?\n |\\.[0-9_]+(?:[eE][-+][0-9]+)?\n |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*\n |[-+, re.VERBOSE)), ('tag:yaml.org,2002:int', re.compile('^(?:[-+]?0b[0-1_]+\n |[-+]?0[0-7_]+\n |[-+]?(?:0|[1-9][0-9_]*)\n |[-+]?0x[0-9a-fA-F_]+\n |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9]), re.VERBOSE))], '6': [('tag:yaml.org,2002:float', re.compile('^(?:[-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+][0-9]+)?\n |\\.[0-9_]+(?:[eE][-+][0-9]+)?\n |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*\n |[-+, re.VERBOSE)), ('tag:yaml.org,2002:int', re.compile('^(?:[-+]?0b[0-1_]+\n |[-+]?0[0-7_]+\n |[-+]?(?:0|[1-9][0-9_]*)\n |[-+]?0x[0-9a-fA-F_]+\n |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9]), re.VERBOSE))], '7': [('tag:yaml.org,2002:float', re.compile('^(?:[-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+][0-9]+)?\n |\\.[0-9_]+(?:[eE][-+][0-9]+)?\n |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*\n |[-+, re.VERBOSE)), ('tag:yaml.org,2002:int', re.compile('^(?:[-+]?0b[0-1_]+\n |[-+]?0[0-7_]+\n |[-+]?(?:0|[1-9][0-9_]*)\n |[-+]?0x[0-9a-fA-F_]+\n |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9]), re.VERBOSE))], '8': [('tag:yaml.org,2002:float', re.compile('^(?:[-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+][0-9]+)?\n |\\.[0-9_]+(?:[eE][-+][0-9]+)?\n |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*\n |[-+, re.VERBOSE)), ('tag:yaml.org,2002:int', re.compile('^(?:[-+]?0b[0-1_]+\n |[-+]?0[0-7_]+\n |[-+]?(?:0|[1-9][0-9_]*)\n |[-+]?0x[0-9a-fA-F_]+\n |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9]), re.VERBOSE))], '9': [('tag:yaml.org,2002:float', re.compile('^(?:[-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+][0-9]+)?\n |\\.[0-9_]+(?:[eE][-+][0-9]+)?\n |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*\n |[-+, re.VERBOSE)), ('tag:yaml.org,2002:int', re.compile('^(?:[-+]?0b[0-1_]+\n |[-+]?0[0-7_]+\n |[-+]?(?:0|[1-9][0-9_]*)\n |[-+]?0x[0-9a-fA-F_]+\n |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9]), re.VERBOSE))], '<': [('tag:yaml.org,2002:merge', re.compile('^(?:<<)$'))], '=': [('tag:yaml.org,2002:value', re.compile('^(?:=)$'))], 'F': [('tag:yaml.org,2002:bool', re.compile('^(?:yes|Yes|YES|no|No|NO\n |true|True|TRUE|false|False|FALSE\n |on|On|ON|off|Off|OFF)$', re.VERBOSE))], 'N': [('tag:yaml.org,2002:bool', re.compile('^(?:yes|Yes|YES|no|No|NO\n |true|True|TRUE|false|False|FALSE\n |on|On|ON|off|Off|OFF)$', re.VERBOSE)), ('tag:yaml.org,2002:null', re.compile('^(?: ~\n |null|Null|NULL\n | )$', re.VERBOSE))], 'O': [('tag:yaml.org,2002:bool', re.compile('^(?:yes|Yes|YES|no|No|NO\n |true|True|TRUE|false|False|FALSE\n |on|On|ON|off|Off|OFF)$', re.VERBOSE))], 'T': [('tag:yaml.org,2002:bool', re.compile('^(?:yes|Yes|YES|no|No|NO\n |true|True|TRUE|false|False|FALSE\n |on|On|ON|off|Off|OFF)$', re.VERBOSE))], 'Y': [('tag:yaml.org,2002:bool', re.compile('^(?:yes|Yes|YES|no|No|NO\n |true|True|TRUE|false|False|FALSE\n |on|On|ON|off|Off|OFF)$', re.VERBOSE))], 'f': [('tag:yaml.org,2002:bool', re.compile('^(?:yes|Yes|YES|no|No|NO\n |true|True|TRUE|false|False|FALSE\n |on|On|ON|off|Off|OFF)$', re.VERBOSE))], 'n': [('tag:yaml.org,2002:bool', re.compile('^(?:yes|Yes|YES|no|No|NO\n |true|True|TRUE|false|False|FALSE\n |on|On|ON|off|Off|OFF)$', re.VERBOSE)), ('tag:yaml.org,2002:null', re.compile('^(?: ~\n |null|Null|NULL\n | )$', re.VERBOSE))], 'o': [('tag:yaml.org,2002:bool', re.compile('^(?:yes|Yes|YES|no|No|NO\n |true|True|TRUE|false|False|FALSE\n |on|On|ON|off|Off|OFF)$', re.VERBOSE))], 't': [('tag:yaml.org,2002:bool', re.compile('^(?:yes|Yes|YES|no|No|NO\n |true|True|TRUE|false|False|FALSE\n |on|On|ON|off|Off|OFF)$', re.VERBOSE))], 'y': [('tag:yaml.org,2002:bool', re.compile('^(?:yes|Yes|YES|no|No|NO\n |true|True|TRUE|false|False|FALSE\n |on|On|ON|off|Off|OFF)$', re.VERBOSE))], '~': [('tag:yaml.org,2002:null', re.compile('^(?: ~\n |null|Null|NULL\n | )$', re.VERBOSE))]}¶
-
classmethod
-
class
lookatme.schemas.NumberingSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.Schema-
class
Meta[source]¶ Bases:
object-
include= {'1': <fields.Nested(dump_default={'text': 'numeric', 'fg': 'bold', 'bg': ''}, attribute=None, validate=None, required=False, load_only=False, dump_only=False, load_default=<marshmallow.missing>, allow_none=False, error_messages={'required': 'Missing data for required field.', 'null': 'Field may not be null.', 'validator_failed': 'Invalid value.', 'type': 'Invalid type.'})>, '2': <fields.Nested(dump_default={'text': 'alpha', 'fg': 'bold', 'bg': ''}, attribute=None, validate=None, required=False, load_only=False, dump_only=False, load_default=<marshmallow.missing>, allow_none=False, error_messages={'required': 'Missing data for required field.', 'null': 'Field may not be null.', 'validator_failed': 'Invalid value.', 'type': 'Invalid type.'})>, '3': <fields.Nested(dump_default={'text': 'roman', 'fg': 'bold', 'bg': ''}, attribute=None, validate=None, required=False, load_only=False, dump_only=False, load_default=<marshmallow.missing>, allow_none=False, error_messages={'required': 'Missing data for required field.', 'null': 'Field may not be null.', 'validator_failed': 'Invalid value.', 'type': 'Invalid type.'})>, '4': <fields.Nested(dump_default={'text': 'numeric', 'fg': 'bold', 'bg': ''}, attribute=None, validate=None, required=False, load_only=False, dump_only=False, load_default=<marshmallow.missing>, allow_none=False, error_messages={'required': 'Missing data for required field.', 'null': 'Field may not be null.', 'validator_failed': 'Invalid value.', 'type': 'Invalid type.'})>, '5': <fields.Nested(dump_default={'text': 'alpha', 'fg': 'bold', 'bg': ''}, attribute=None, validate=None, required=False, load_only=False, dump_only=False, load_default=<marshmallow.missing>, allow_none=False, error_messages={'required': 'Missing data for required field.', 'null': 'Field may not be null.', 'validator_failed': 'Invalid value.', 'type': 'Invalid type.'})>, '6': <fields.Nested(dump_default={'text': 'roman', 'fg': 'bold', 'bg': ''}, attribute=None, validate=None, required=False, load_only=False, dump_only=False, load_default=<marshmallow.missing>, allow_none=False, error_messages={'required': 'Missing data for required field.', 'null': 'Field may not be null.', 'validator_failed': 'Invalid value.', 'type': 'Invalid type.'})>}¶
-
-
opts= <marshmallow.schema.SchemaOpts object>¶
-
class
-
class
lookatme.schemas.ScrollbarGutterSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.SchemaSchema for the slider on the scrollbar
-
opts= <marshmallow.schema.SchemaOpts object>¶
-
-
class
lookatme.schemas.ScrollbarSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.SchemaSchema for the scroll bar
-
opts= <marshmallow.schema.SchemaOpts object>¶
-
-
class
lookatme.schemas.ScrollbarSliderSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.SchemaSchema for the slider on the scrollbar
-
opts= <marshmallow.schema.SchemaOpts object>¶
-
-
class
lookatme.schemas.SpacingSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.Schema-
opts= <marshmallow.schema.SchemaOpts object>¶
-
-
class
lookatme.schemas.StyleFieldSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.Schema-
opts= <marshmallow.schema.SchemaOpts object>¶
-
-
class
lookatme.schemas.StyleSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.SchemaStyles schema for themes and style overrides within presentations
-
class
Meta[source]¶ Bases:
object-
render_module¶ alias of
YamlRender
-
unknown= 'raise'¶
-
-
opts= <marshmallow.schema.SchemaOpts object>¶
-
class
-
class
lookatme.schemas.TableSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.Schema-
opts= <marshmallow.schema.SchemaOpts object>¶
-
-
class
lookatme.schemas.TextStyleFieldSchema(*, only: types.StrSequenceOrSet | None = None, exclude: types.StrSequenceOrSet = (), many: bool = False, context: dict | None = None, load_only: types.StrSequenceOrSet = (), dump_only: types.StrSequenceOrSet = (), partial: bool | types.StrSequenceOrSet = False, unknown: str | None = None)[source]¶ Bases:
marshmallow.schema.Schema-
opts= <marshmallow.schema.SchemaOpts object>¶
-
lookatme.slide module¶
Slide info holder
lookatme.templating module¶
This module provides basic templating functionality
lookatme.tui module¶
This module defines the text user interface (TUI) for lookatme
-
class
lookatme.tui.MarkdownTui(pres, start_idx=0, no_threads=False)[source]¶ Bases:
urwid.container.Frame
-
class
lookatme.tui.SlideRenderer(ctx: lookatme.render.context.Context)[source]¶ Bases:
threading.Thread-
daemon= True¶
-
do_render(to_render, slide_num)[source]¶ Perform the actual rendering of a slide. This is done by:
- parsing the slide into tokens (should have occurred already)
- iterating through each parsed markdown token
- calling the appropriately-named render function for the
token["type"]inlookatme.render.markdown_block
Each render function must have the signature:
def render_XXX(token, body, stack, loop): pass
The arguments to the render function are described below:
token- the lexed markdown token - a dictionarybody- the currenturwid.Pile()that return values will be added to (same asstack[-1])stack- The stack ofurwid.Pile()used during rendering. E.g., when rendering nested lists, each nested list will push a newurwid.Pile()to the stack, each wrapped with its own additional indentation.loop- theurwid.MainLoopinstance being used by lookatme. This won’t usually be used, but is available if needed.
Main render functions (those defined in markdown_block.py) may have three types of return values:
None- nothing is added tostack[-1]. Perhaps the render function only needed to add additional indentation by pushing a newurwid.Pile()to the stack.list(urwid.Widget)- A list of widgets to render. These will automatically be added to the Pile atstack[-1]urwid.Widget- A single widget to render. Will be added tostack[-1]automatically.
-
-
lookatme.tui.create_tui(pres, start_slide=0, no_threads=False)[source]¶ Run the provided presentation
Parameters: start_slide (int) – 0-based slide index
lookatme.tutorial module¶
Functions and sources for the markdown tutorial slides!
-
class
lookatme.tutorial.Tutor(name: str, group: str, slides_md: str, impl_fn: Callable, order: float, lazy_formatting: Optional[Callable] = None)[source]¶ Bases:
objectA class to handle/process tutorials for specific functionality
In addition to name, group, and slides content of the tutor, each Tutor must also be associated with the implementation.