Need an action that can turn line numbers on or off

Looks like the last item in HighlightChain stays highlighted after the chain runs

In REPL mode, when a REPL line is only a comment, skip the typewriter animation

(Maybe make this an option?)

Add escape sequence for controlling of animation or presentation

Example use cases:

• presenting in a certain format foreign to the context
• Generic highlighting (colour sequencing) for things that don't have parsers
• Timing of animation (insert pauses between response lines for things like terminal commands that take time)
• Animation sequences (progress bars)

Ability to change the size of the code boxes midway through program

HighlightChain and any other chaining sequences should use tuples instead of strings for mutli-sets

Should also support *args instead of needing a list

Some sort of file format that allows for mixing context highlighting

Single presentation for going from BASH to REPL and back again

While writing the script and rehearsing, I have to change small pieces of the script now and then, but still restart the entire script and go though the whole thing again.

Therefore it would be quite a timesaver when hot reloading could be added to Purdy.

Add ability to highlight portions of a line

chain as well?

Appending:

"""

Stuff
"""

Results in just "Stuff" being appended, no \n.

Probably some code to deal with blanks buried somewhere, but removing it may break other things.

Save for the re-write.

Add ability to change animation speed (command line arg? key press?)

Add ability to do an action to just part of a Code object. Example AppendTypewriter(line_start=3, line_end=15).

py console lexer should be look for ".repl" extensions and be called "repl"

"con" should be used for "bash" as that is the file extension

Add Action that can change properties of the screen object (example: turn auto scroll or line numbers on and off)

Change behaviour so that if "purdy_lexer" is provided, the lexer_name parm is ignored, saves extra parameter

Add a parameter to Append() and its siblings that allows you to insert pauses between output lines

Possible example:

Append(box, code, pauses=[Pause(3, 1.5), Pause(4, 1.5)])

Where 3 is the line to pause after, 1.5 the amount of time

allow for a title bar

have a fixed mode that stays at top during scroll?

A new animation class that takes a chunk of code, debug line numbers, a chunk of text, and pause points in the output.

The code is displayed in one box while the output is displayed in the other. Each "breakpoint" in the code is matched to a pause in the output, and as you proceed through the animation it shows the next chunk of output. Kind of like highlight chain but looking like there is a debugger.

Hi @cltrudeau,

In order to have a bit shorter syntax when working with Purdy, I created a class to create all actions:

class ActionsBuilder(Iterable):
    def __init__(self, code_box, lexer_name: str) -> None:
        self.__code_box = code_box
        self.__lexer_name = lexer_name
        self.__actions = []

    def __iter__(self):
        return iter(self.__actions)

    def append_typewriter(self, text: str = "", filename: str = "") -> "ActionsBuilder":
        self.__actions.append(
            AppendTypewriter(
                self.__code_box,
                Code(filename=filename, text=text, lexer_name=self.__lexer_name),
            )
        )
        return self

    def append(self, text: str = "", filename: str = "") -> "ActionsBuilder":
        self.__actions.append(
            Append(
                self.__code_box,
                Code(filename=filename, text=text, lexer_name=self.__lexer_name),
            )
        )
        return self

    def suffix(self, position, source) -> "ActionsBuilder":
        self.__actions.append(Suffix(self.__code_box, position, source))
        return self

    def wait(self) -> "ActionsBuilder":
        self.__actions.append(Wait())
        return self

    def clear(self) -> "ActionsBuilder":
        self.__actions.append(Clear(self.__code_box))
        return self

This class allows me to create a set of actions like this:

screen = SimpleScreen(starting_line_number=-1, settings=settings)
code_box = screen.code_box

actions = (
    ActionsBuilder(code_box, lexer_name="bash")
    .append_typewriter("$ pyenv versions")
    .append("* system\n  3.9.0\n  3.9.1")
    .append_typewriter("$ pyenv global 3.9.1")
    .append_typewriter("$ python -V")
    .append("Python 3.9.0")
    .append_typewriter("$ pyenv global system")
    .append_typewriter("$ python -V")
    .append("Python 2.7.16")
    .append_typewriter("$ ")
)

screen.run(actions)

Would you like to add this class to be added to Purdy? If so, I'm more than happy to create a PR for you. 😃

Add action that causes screen to scroll to a given line number

Support -1 for bottom

Two modes? Skip straight and animated scrolling?

Should fold be an action? Should it be something done on a Code item instead?

Consequences: how do line numbers behave if so, sometimes want folding with removal, sometimes don't.

Think about this when dealing with the re-design of Code and its ability to show parts.

For anything that doesn't require highlighting, a lexer that has no colouring might be useful. (Requested by Leodanis)

Add "none" as a supported value for the "-l" option

Add a chaining method so that sets of lines can be trimmed at the same time -- makes it easier to figure out based on original file line numbers instead of the edit of an edit.

Highlight part of a line

With HighlightChain, allow ["1.2-1.5"] to highlight line 1 characters 2 through 5

Using typewriter mode on a dbash based lexer uses the typewriter animation to show the prompt.

Either the prompt isn't being treated as a whole token

or there is a bug in the animation sequence.

Add ability to do multiple calls to Code.subset() in a single call to split up a document

Maybe has two versions, one that just takes the starting line numbers of chunks and one that specifies a sequence of start-end specifiers

Either completely re-think how this works (some sort of generator so that actions can advance part-way through blocks), or add ability to specify end=-1

Looks like the transition wipe is processing the entire file instead of optimizing for what is shown on screen. Longer files have a delay before the transition starts if you're scrolled down.

Often end up doing a "prompt" line in output. Want to be able to do:

Name: John

Where name is spit out, while "John" is typed

Currently done with multiple Appends and SuffixTypewriter commands, could be mixed into one.

Using the "none" lexer seems to not split things on multiple lines, or somehow the lines can't highlight correctly

See RP 039_jinja/demo and try to highlight some of the template code lines

Last item in a highlight chain stays highlighted

Add lexers for HTML and HTML in Django/Jinja mode

Add ability to highlight sets of lines in a chain

Need new character? ["1-3&5"] for 1-3 and 5

Can't currently do a Transition animation on the whole screen. Use case: TwinRowBoxes, want to clear both of them. Maybe provide initial state new box.

Could also re-examine how Transition works -- maybe it is just an animated clear, with the next action populating the new view. Transition-in and Transition-out being separate animations.

folded lines don't respect the line number display --> it is a simple replace, rather than a fold

Currently indent spaces are treated as characters in typewriter mode. The animation should be smarter and go directly to the code part of the line.