Miscellaneous George functions

All George values as enum and functions which are not specific to any TVPaint element.

GrgErrorValue

Common George error values.

Attributes:

Name	Type	Description
EMPTY	str	See tv_clipinfo for example
NONE	str	See tv_clipenumid for example
ERROR	str	See tv_setapen for example

GrgBoolState

Bases: enum.Enum

George booleans.

Attributes:

Name	Type	Description
ON
OFF

FieldOrder

Bases: enum.Enum

Field order of the camera.

Attributes:

Name	Type	Description
NONE
LOWER
UPPER

MarkType

Bases: enum.Enum

The mark command.

Attributes:

Name	Type	Description
MARKIN
MARKOUT

MarkReference

Bases: enum.Enum

The object to mark.

Attributes:

Name	Type	Description
PROJECT
CLIP

MarkAction

Bases: enum.Enum

The mark action.

Attributes:

Name	Type	Description
SET
CLEAR

RectButton

Bases: enum.Enum

The rect button when drawing.

Attributes:

Name	Type	Description
LEFT
RIGHT

TVPShape

Bases: enum.Enum

The shape tools.

Attributes:

Name	Type	Description
B_SPLINE
BEZIER
BEZIER_FILL
CAMERA
CIRCLE
CIRCLE_2PTS
CIRCLE_3PTS
CIRCLE_FILL
CIRCLE_2PTS_FILL
CIRCLE_3PTS_FILL
CROP
CUT_RECT
CUT_POLY
CUT_FREE_HAND
CUT_FLOOD
DOT
FLOOD
FREE_HAND_LINE
FREE_HAND_FILL
ELLIPSE
ELLIPSE_FILL
ELLIPSE_2PTS
ELLIPSE_2PTS_FILL
LINE
LINE_FILL
PLANNING
POSITION
RECTANGLE
RECTANGLE_FILL
SELECT_RECTANGLE
SELECT_ELLIPSE
SELECT_2PTS
SELECT_3PTS
SELECT_POLY
SELECT_FREE_HAND
SELECT_FLOOD
SELECT_COLOR
SELECT_BEZIER
SELECT_B_SPLINE
SINGLE_DOT
SPLIT_3PTS
SPLINE_FILL
WARP
WRAP
ZOOM_IN
ZOOM_OUT
ZOOM_HAND
ZOOM_RECT

ResizeOption

Bases: enum.Enum

Resize options for projects.

Attributes:

Name	Type	Description
EMPTY
CROP
STRETCH

SpriteLayout

Bases: enum.Enum

Sprite layout when exporting as sprites.

Attributes:

Name	Type	Description
RECTANGLE
HORIZONTAL
VERTICAL
DIAGONAL
ANTI_DIAGONAL

AlphaMode

Bases: enum.Enum

The alpha load mode.

Attributes:

Name	Type	Description
PREMULTIPLY
NO_PREMULTIPLY
NO_ALPHA
ALPHA_ONLY
GUESS

AlphaSaveMode

Bases: enum.Enum

The alpha save mode.

Attributes:

Name	Type	Description
PREMULTIPLY
NO_PREMULTIPLY
NO_ALPHA
ALPHA_ONLY
GUESS
ALPHA_BINARY

SaveFormat

Bases: enum.Enum

All save formats.

Attributes:

Name	Type	Description
AVI
BMP
CINEON
DEEP
DPX
FLI
GIF
ILBM
JPG		jpeg
MKV		Mode=1017
MOV		Mode=1015
MP4		Mode=1016
PCX
PDF
PNG
PSD
SGI		Mode=16
SOFTIMAGE		Mode=10
SUNRASTER		sun
TGA		tga
TIFF		Mode=15
VPB
WEBM		Mode=1018

from_extension(extension: str) -> SaveFormat classmethod

Returns the correct tvpaint format value from a string extension.

Source code in pytvpaint/george/grg_base.py

@classmethod
def from_extension(cls, extension: str) -> SaveFormat:
    """Returns the correct tvpaint format value from a string extension."""
    extension = extension.replace(".", "").upper()
    if not hasattr(SaveFormat, extension):
        raise ValueError(
            f"Could not find format ({extension}) in accepted formats ({SaveFormat})"
        )
    return cast(SaveFormat, getattr(cls, extension.upper()))

is_image(extension: str) -> bool classmethod

Returns True if the extension correspond to an image format.

Source code in pytvpaint/george/grg_base.py

@classmethod
def is_image(cls, extension: str) -> bool:
    """Returns True if the extension correspond to an image format."""
    extension = extension.replace(".", "").lower()
    image_formats = [
        "bmp",
        "cin",
        "deep",
        "dpx",
        "ilbm",
        "jpg",
        "jpeg",
        "pcx",
        "png",
        "psd",
        "sgi",
        "pic",
        "ras",
        "sun",
        "tga",
        "tiff",
    ]
    return extension in image_formats

RGBColor(r: int, g: int, b: int) dataclass

RGB color with 0-255 range values.

HSLColor(h: int, s: int, l: int) dataclass

HSL color. Maximum values are (360, 100, 100) for h, s, l.

BlendingMode

Bases: enum.Enum

All the blending modes.

Attributes:

Name	Type	Description
COLOR
BEHIND
ERASE
SHADE
LIGHT
COLORIZE
HUE
SATURATION
VALUE
ADD
SUB
MULTIPLY
SCREEN
REPLACE
COPY
DIFFERENCE
DIVIDE
OVERLAY
OVERLAY2
LIGHT2
SHADE2
HARDLIGHT
SOFTLIGHT
GRAIN_EXTRACT
GRAIN_MERGE
SUB2
DARKEN
LIGHTEN

DrawingMode

Bases: enum.Enum

All the drawing modes.

Attributes:

Name	Type	Description
COLOR
BEHIND
ERASE
PANTO
MERGE
SHADE
LIGHT
COLORIZE
TINT
GRAIN
BLUR
NOISE
NEGATIVE
SHARP
EMBOSS
SOLARIZE
SATURATE
UNSATURATE
ADD
SUB
MULTIPLY
SCREEN
DIFF
HEALING
BURN
DODGE
DARKEN
LIGHTEN

MenuElement

Bases: enum.Enum

All the TVPaint menu elements.

Attributes:

Name	Type	Description
SHOW_UI
HIDE_UI
RESIZE_UI
CENTER_DISPLAY
FIT_DISPLAY
FRONT
BACK
ASPECT_RATIO
CLIP
PROJECT
XSHEET
NOTES

FileMode

Bases: enum.Enum

File mode save or load.

Attributes:

Name	Type	Description
SAVE
LOAD

TVPPenBrush(mode: DrawingMode, size: float, power: int, opacity: int, dry: bool, aaliasing: bool, gradient: bool, csize: str, cpower: str) dataclass

A TVPaint brush.

TVPSound(offset: float, volume: float, mute: bool, fade_in_start: float, fade_in_stop: float, fade_out_start: float, fade_out_stop: float, path: Path, sound_in: float, sound_out: float, color_index: int) dataclass

A TVPaint sound (clip and project).

undoable(func: T) -> T

Decorator to register actions in the TVPaint undo stack.

Source code in pytvpaint/george/grg_base.py

def undoable(func: T) -> T:
    """Decorator to register actions in the TVPaint undo stack."""

    def wrapper(*args: Any, **kwargs: Any) -> T:
        tv_undo_open_stack()
        res = func(*args, **kwargs)
        tv_undo_close_stack(func.__name__)
        return cast(T, res)

    return cast(T, wrapper)

undoable_stack() -> Generator[None, None, None]

Context manager that creates an undo stack. Useful to undo a sequence of George actions.

Source code in pytvpaint/george/grg_base.py

@contextlib.contextmanager
def undoable_stack() -> Generator[None, None, None]:
    """Context manager that creates an undo stack. Useful to undo a sequence of George actions."""
    tv_undo_open_stack()
    yield
    tv_undo_close_stack()

tv_warn(msg: str) -> None

Display a warning message.

Source code in pytvpaint/george/grg_base.py

def tv_warn(msg: str) -> None:
    """Display a warning message."""
    send_cmd("tv_Warn", msg)

tv_version() -> tuple[str, str, str]

Returns the software name, version and language.

Source code in pytvpaint/george/grg_base.py

def tv_version() -> tuple[str, str, str]:
    """Returns the software name, version and language."""
    cmd_fields = [
        ("software_name", str),
        ("version", str),
        ("language", str),
    ]
    res = tv_parse_list(send_cmd("tv_Version"), with_fields=cmd_fields)
    software_name, version, language = res.values()
    return software_name, version, language

tv_quit() -> None

Closes the TVPaint instance.

Source code in pytvpaint/george/grg_base.py

def tv_quit() -> None:
    """Closes the TVPaint instance."""
    send_cmd("tv_Quit")

tv_host2back() -> None

Minimize the TVPaint window.

Source code in pytvpaint/george/grg_base.py

def tv_host2back() -> None:
    """Minimize the TVPaint window."""
    send_cmd("tv_Host2Back")

tv_host2front() -> None

Restore the TVPaint window after being minimized.

Source code in pytvpaint/george/grg_base.py

def tv_host2front() -> None:
    """Restore the TVPaint window after being minimized."""
    send_cmd("tv_Host2Front")

tv_menu_hide() -> None

Switch to inlay view and hide all non-docking panels.

Source code in pytvpaint/george/grg_base.py

def tv_menu_hide() -> None:
    """Switch to inlay view and hide all non-docking panels."""
    send_cmd("tv_MenuHide")

add_some_magic(i_am_a_badass: bool = False, magic_number: int | None = None) -> None

Don't use ! Will change your life forever...

Source code in pytvpaint/george/grg_base.py

def add_some_magic(
    i_am_a_badass: bool = False, magic_number: int | None = None
) -> None:
    """Don't use ! Will change your life forever..."""
    if not i_am_a_badass:
        log.warning("Sorry, you're not enough of a badass for this function...")

    magic_number = magic_number or 14
    send_cmd("tv_MagicNumber", magic_number)
    log.info("Totally worth it, right ? ^^")

tv_menu_show(menu_element: MenuElement | None = None, *menu_options: Any, current: bool = False) -> None

For the complete documentation, see: https://www.tvpaint.com/doc/tvpaint-animation-11/george-commands#tv_menushow.

Source code in pytvpaint/george/grg_base.py

def tv_menu_show(
    menu_element: MenuElement | None = None, *menu_options: Any, current: bool = False
) -> None:
    """For the complete documentation, see: https://www.tvpaint.com/doc/tvpaint-animation-11/george-commands#tv_menushow."""
    cmd_args: list[str] = []

    if current:
        cmd_args.append("current")

    if menu_element:
        cmd_args.append(menu_element.value)

    send_cmd("tv_MenuShow", *cmd_args, *menu_options)

tv_request(msg: str, confirm_text: str = 'Yes', cancel_text: str = 'No') -> bool

Open a confirmation prompt with a message.

Parameters:

Name	Type	Description	Default
msg	str	the message to display	required
confirm_text	str	the confirm button text. Defaults to "Yes".	'Yes'
cancel_text	str	the cancel button text. Defaults to "No".	'No'

Returns:

Name	Type	Description
bool	bool	True if clicked on "Yes"

Source code in pytvpaint/george/grg_base.py

def tv_request(msg: str, confirm_text: str = "Yes", cancel_text: str = "No") -> bool:
    """Open a confirmation prompt with a message.

    Args:
        msg: the message to display
        confirm_text: the confirm button text. Defaults to "Yes".
        cancel_text: the cancel button text. Defaults to "No".

    Returns:
        bool: True if clicked on "Yes"
    """
    return bool(int(send_cmd("tv_Request", msg, confirm_text, cancel_text)))

tv_req_num(value: int, min: int, max: int, title: str = 'Enter Value') -> int | None

Open a prompt to request an integer (within a range).

Parameters:

Name	Type	Description	Default
value	int	the initial value	required
min	int	the minimum value	required
max	int	the maximum value	required
title	str	title of the prompt dialog. Defaults to "Enter Value".	'Enter Value'

Returns:

Type	Description
int | None	the value or None if cancelled

Source code in pytvpaint/george/grg_base.py

def tv_req_num(
    value: int, min: int, max: int, title: str = "Enter Value"
) -> int | None:
    """Open a prompt to request an integer (within a range).

    Args:
        value: the initial value
        min: the minimum value
        max: the maximum value
        title: title of the prompt dialog. Defaults to "Enter Value".

    Returns:
        the value or None if cancelled
    """
    res = send_cmd("tv_ReqNum", value, min, max, title, handle_string=False)
    return None if res.lower() == "cancel" else int(res)

tv_req_angle(value: float, min: float, max: float, title: str = 'Enter Value') -> float | None

Open a prompt to request an angle (in degree).

Parameters:

Name	Type	Description	Default
value	float	the initial value	required
min	float	the minimum value	required
max	float	the maximum value	required
title	str	title of the prompt. Defaults to "Enter Value".	'Enter Value'

Returns:

Type	Description
float | None	the value or None if cancelled

Source code in pytvpaint/george/grg_base.py

def tv_req_angle(
    value: float, min: float, max: float, title: str = "Enter Value"
) -> float | None:
    """Open a prompt to request an angle (in degree).

    Args:
        value: the initial value
        min: the minimum value
        max: the maximum value
        title: title of the prompt. Defaults to "Enter Value".

    Returns:
        the value or None if cancelled
    """
    res = send_cmd("tv_ReqAngle", value, min, max, title, handle_string=False)
    return None if res.lower() == "cancel" else float(res)

tv_req_float(value: float, min: float, max: float, title: str = 'Enter value') -> float | None

Open a prompt to request a float.

Parameters:

Name	Type	Description	Default
value	float	the initial value	required
min	float	the minimum value	required
max	float	the maximum value	required
title	str	title of the prompt. Defaults to "Enter Value".	'Enter value'

Returns:

Type	Description
float | None	the value or None if cancelled

Source code in pytvpaint/george/grg_base.py

def tv_req_float(
    value: float, min: float, max: float, title: str = "Enter value"
) -> float | None:
    """Open a prompt to request a float.

    Args:
        value: the initial value
        min: the minimum value
        max: the maximum value
        title: title of the prompt. Defaults to "Enter Value".

    Returns:
        the value or None if cancelled
    """
    res = send_cmd("tv_ReqFloat", value, min, max, title, handle_string=False)
    return None if res.lower() == "cancel" else float(res)

tv_req_string(title: str, text: str) -> str | None

Open a prompt to request a string.

Parameters:

Name	Type	Description	Default
title	str	title of the requester. Defaults to "Enter Value".	required
text	str	the initial value	required

Returns:

Type	Description
str | None	the value or None if cancelled

Source code in pytvpaint/george/grg_base.py

def tv_req_string(title: str, text: str) -> str | None:
    """Open a prompt to request a string.

    Args:
        title: title of the requester. Defaults to "Enter Value".
        text: the initial value

    Returns:
        the value or None if cancelled
    """
    cmd_args = ["|".join([title, text])]
    if "\n" in text:
        cmd_args.insert(0, "multiline")
    res = send_cmd("tv_ReqString", *cmd_args, handle_string=False)
    return None if res.lower() == "cancel" else res

tv_list_request(entries: list[Entry]) -> tuple[int, str]

Open a prompt to request a selection in a list.

Parameters:

Name	Type	Description	Default
entries	list[pytvpaint.george.grg_base.Entry]	the list of entries (either a single entry or sub entries)	required

Returns:

Type	Description
tuple[int, str]	the position, the entry

Source code in pytvpaint/george/grg_base.py

def tv_list_request(entries: list[Entry]) -> tuple[int, str]:
    """Open a prompt to request a selection in a list.

    Args:
        entries: the list of entries (either a single entry or sub entries)

    Returns:
        the position, the entry
    """
    entries_str = "|".join(map(_entry_to_str, entries))
    res = send_cmd("tv_ListRequest", entries_str, error_values=["-1 Cancel"])
    res_obj = tv_parse_list(
        res,
        with_fields=[
            ("index", int),
            ("entry", str),
        ],
    )
    index, entry = tuple(res_obj.values())
    return int(index), entry

tv_req_file(mode: FileMode, title: str = '', working_dir: Path | str | None = None, default_name: str | None = None, extension_filter: str | None = None) -> Path | None

Open a prompt to request a file.

Parameters:

Name	Type	Description	Default
mode	pytvpaint.george.grg_base.FileMode	save or load	required
title	str	the title of the request	''
working_dir	pathlib.Path | str | None	the default folder to go. Defaults to None.	None
default_name	str | None	the default name. Defaults to None.	None
extension_filter	str | None	display the files with this extension. Defaults to None.	None

Returns:

Type	Description
pathlib.Path | None	the choosen path or None if cancelled

Source code in pytvpaint/george/grg_base.py

def tv_req_file(
    mode: FileMode,
    title: str = "",
    working_dir: Path | str | None = None,
    default_name: str | None = None,
    extension_filter: str | None = None,
) -> Path | None:
    """Open a prompt to request a file.

    Args:
        mode: save or load
        title: the title of the request
        working_dir: the default folder to go. Defaults to None.
        default_name: the default name. Defaults to None.
        extension_filter: display the files with this extension. Defaults to None.

    Returns:
        the choosen path or None if cancelled
    """
    cmd_args = [
        title,
        Path(working_dir).as_posix() if working_dir else None,
        default_name,
        extension_filter,
    ]

    arg_str = "|".join([v if v is not None else "" for v in cmd_args])
    res = send_cmd("tv_ReqFile", f"{mode.value} {arg_str}", handle_string=False)

    return None if res.lower() == "cancel" else Path(res)

tv_undo() -> None

Do an undo.

Source code in pytvpaint/george/grg_base.py

def tv_undo() -> None:
    """Do an undo."""
    send_cmd("tv_Undo")

tv_update_undo() -> None

Copies the contents of the current image in the current layer into the buffer undo memory.

None of the draw commands described in this section updates this buffer memory. If you click on the Undo button after executing a George program, everything that the program has drawn in your image will be deleted. With this function you can update the undo buffer memory whenever you wish (for example at the beginning of the program).

Source code in pytvpaint/george/grg_base.py

def tv_update_undo() -> None:
    """Copies the contents of the current image in the current layer into the buffer undo memory.

    None of the draw commands described in this section updates this buffer memory.
    If you click on the Undo button after executing a George program, everything that the program has drawn in your image will be deleted.
    With this function you can update the undo buffer memory whenever you wish (for example at the beginning of the program).
    """
    send_cmd("tv_UpdateUndo")

tv_undo_open_stack() -> None

Open an 'undo' stack.

Surround a piece of code with tv_undoopenstack ... tv_undoclosestack, then multiple undo will be added to this stack, and closing this stack will undo everything inside. (To be sure the script returns to the expected result use tv_updateundo before tv_undoopenstack)

Source code in pytvpaint/george/grg_base.py

def tv_undo_open_stack() -> None:
    """Open an 'undo' stack.

    Surround a piece of code with tv_undoopenstack ... tv_undoclosestack, then multiple undo will be added to this stack, and closing this stack will undo everything inside.
    (To be sure the script returns to the expected result use tv_updateundo before tv_undoopenstack)
    """
    send_cmd("tv_UndoOpenStack")

tv_undo_close_stack(name: str = '') -> None

Close an 'undo' stack (See tv_undo_open_stack).

Source code in pytvpaint/george/grg_base.py

def tv_undo_close_stack(name: str = "") -> None:
    """Close an 'undo' stack (See tv_undo_open_stack)."""
    send_cmd("tv_UndoCloseStack", name)

tv_save_mode_get() -> tuple[SaveFormat, list[str]]

Get the saving alpha mode.

Source code in pytvpaint/george/grg_base.py

def tv_save_mode_get() -> tuple[SaveFormat, list[str]]:
    """Get the saving alpha mode."""
    res = send_cmd("tv_SaveMode")
    res_split = res.split()
    save_format = tv_cast_to_type(res_split.pop(0), SaveFormat)
    return save_format, res_split

tv_save_mode_set(save_format: SaveFormat, *format_options: str | int | float) -> None

Set the saving alpha mode.

Source code in pytvpaint/george/grg_base.py

def tv_save_mode_set(
    save_format: SaveFormat, *format_options: str | int | float
) -> None:
    """Set the saving alpha mode."""
    send_cmd("tv_SaveMode", save_format.value, *format_options)

tv_alpha_load_mode_get() -> AlphaMode

Set the loading alpha mode.

Source code in pytvpaint/george/grg_base.py

def tv_alpha_load_mode_get() -> AlphaMode:
    """Set the loading alpha mode."""
    res = send_cmd("tv_AlphaLoadMode")
    return tv_cast_to_type(res, AlphaMode)

tv_alpha_load_mode_set(mode: AlphaMode) -> None

Get the loading alpha mode.

Source code in pytvpaint/george/grg_base.py

def tv_alpha_load_mode_set(mode: AlphaMode) -> None:
    """Get the loading alpha mode."""
    send_cmd("tv_AlphaLoadMode", mode.value)

tv_alpha_save_mode_get() -> AlphaSaveMode

Get the saving alpha mode.

Source code in pytvpaint/george/grg_base.py

def tv_alpha_save_mode_get() -> AlphaSaveMode:
    """Get the saving alpha mode."""
    res = send_cmd("tv_AlphaSaveMode")
    return tv_cast_to_type(res, AlphaSaveMode)

tv_alpha_save_mode_set(mode: AlphaSaveMode) -> None

Set the saving alpha mode.

Source code in pytvpaint/george/grg_base.py

def tv_alpha_save_mode_set(mode: AlphaSaveMode) -> None:
    """Set the saving alpha mode."""
    send_cmd("tv_AlphaSaveMode", mode.value)

tv_mark_in_get(reference: MarkReference) -> tuple[int, MarkAction]

Get markin of the project / clip.

Source code in pytvpaint/george/grg_base.py

def tv_mark_in_get(
    reference: MarkReference,
) -> tuple[int, MarkAction]:
    """Get markin of the project / clip."""
    return _tv_mark(MarkType.MARKIN, reference)

tv_mark_in_set(reference: MarkReference, frame: int | None, action: MarkAction) -> tuple[int, MarkAction]

Set markin of the project / clip.

Source code in pytvpaint/george/grg_base.py

def tv_mark_in_set(
    reference: MarkReference,
    frame: int | None,
    action: MarkAction,
) -> tuple[int, MarkAction]:
    """Set markin of the project / clip."""
    return _tv_mark(MarkType.MARKIN, reference, frame, action)

tv_mark_out_get(reference: MarkReference) -> tuple[int, MarkAction]

Get markout of the project / clip.

Source code in pytvpaint/george/grg_base.py

def tv_mark_out_get(
    reference: MarkReference,
) -> tuple[int, MarkAction]:
    """Get markout of the project / clip."""
    return _tv_mark(MarkType.MARKOUT, reference)

tv_mark_out_set(reference: MarkReference, frame: int | None, action: MarkAction) -> tuple[int, MarkAction]

Set markout of the project / clip.

Source code in pytvpaint/george/grg_base.py

def tv_mark_out_set(
    reference: MarkReference, frame: int | None, action: MarkAction
) -> tuple[int, MarkAction]:
    """Set markout of the project / clip."""
    return _tv_mark(MarkType.MARKOUT, reference, frame, action)

tv_get_active_shape() -> TVPShape

Get the current shape.

Source code in pytvpaint/george/grg_base.py

def tv_get_active_shape() -> TVPShape:
    """Get the current shape."""
    return tv_cast_to_type(send_cmd("tv_GetActiveShape"), TVPShape)

tv_set_active_shape(shape: TVPShape, **shape_kwargs: Any) -> None

Set the current shape and its tool parameters.

Parameters:

Name	Type	Description	Default
shape	pytvpaint.george.grg_base.TVPShape	the shape to set	required
**shape_kwargs	typing.Any	the shape specific parameters as keyword arguments	{}

Source code in pytvpaint/george/grg_base.py

def tv_set_active_shape(shape: TVPShape, **shape_kwargs: Any) -> None:
    """Set the current shape and its tool parameters.

    Args:
        shape: the shape to set
        **shape_kwargs: the shape specific parameters as keyword arguments
    """
    send_cmd("tv_SetActiveShape", shape.value, *args_dict_to_list(shape_kwargs))

tv_set_a_pen_rgba(color: RGBColor, alpha: int | None = None) -> RGBColor

Set the APen RGBA color.

Source code in pytvpaint/george/grg_base.py

def tv_set_a_pen_rgba(color: RGBColor, alpha: int | None = None) -> RGBColor:
    """Set the APen RGBA color."""
    return _tv_set_ab_pen("a", color.r, color.g, color.b, "rgb", a=alpha)

tv_set_a_pen_hsl(color: HSLColor) -> HSLColor

Set the A Pen HSL color.

Source code in pytvpaint/george/grg_base.py

def tv_set_a_pen_hsl(color: HSLColor) -> HSLColor:
    """Set the A Pen HSL color."""
    return _tv_set_ab_pen("a", color.h, color.s, color.l, color_format="hsl")

tv_set_b_pen_rgba(color: RGBColor, alpha: int | None = None) -> RGBColor

Set the B Pen RGBA color.

Source code in pytvpaint/george/grg_base.py

def tv_set_b_pen_rgba(color: RGBColor, alpha: int | None = None) -> RGBColor:
    """Set the B Pen RGBA color."""
    return _tv_set_ab_pen("b", color.r, color.g, color.b, color_format="rgb", a=alpha)

tv_set_b_pen_hsl(color: HSLColor) -> HSLColor

Set the B Pen HSL color.

Source code in pytvpaint/george/grg_base.py

def tv_set_b_pen_hsl(color: HSLColor) -> HSLColor:
    """Set the B Pen HSL color."""
    return _tv_set_ab_pen("b", color.h, color.s, color.l, color_format="hsl")

tv_pen(size: float) -> float

Change current pen tool size. This function is most likely deprecated it is undocumented in the George reference but still works.

Source code in pytvpaint/george/grg_base.py

def tv_pen(size: float) -> float:
    """Change current pen tool size. This function is most likely deprecated it is undocumented in the George reference but still works."""
    res = tv_parse_dict(send_cmd("tv_Pen", size), with_fields=[("size", float)])
    return cast(float, res["size"])

tv_pen_brush_get(tool_mode: bool = False) -> TVPPenBrush

Get pen brush parameters.

Source code in pytvpaint/george/grg_base.py

def tv_pen_brush_get(tool_mode: bool = False) -> TVPPenBrush:
    """Get pen brush parameters."""
    args = ("toolmode", "backup") if tool_mode else ("backup",)
    result = send_cmd("tv_PenBrush", *args)

    # Remove the first value which is tv_penbrush
    result = result[len("tv_penbrush") + 1 :]

    res = tv_parse_dict(result, with_fields=TVPPenBrush)
    return TVPPenBrush(**res)

tv_pen_brush_set(mode: DrawingMode | None = None, size: int | None = None, opacity: int | None = None, tool_mode: bool = False, reset: bool = False) -> TVPPenBrush

Manage pen brush.

Source code in pytvpaint/george/grg_base.py

def tv_pen_brush_set(
    mode: DrawingMode | None = None,
    size: int | None = None,
    opacity: int | None = None,
    tool_mode: bool = False,
    reset: bool = False,
) -> TVPPenBrush:
    """Manage pen brush."""
    args = {
        "mode": mode.value if mode else None,
        "size": size,
        "opacity": opacity,
    }

    args_list = args_dict_to_list(args)

    if tool_mode:
        args_list.append("toolmode")
    if reset:
        args_list.append("reset")

    send_cmd("tv_PenBrush", *args_list)

    # Since TVPaint is returning only the values that were modified
    # this is almost impossible to parse so we call get
    return tv_pen_brush_get()

tv_line(xy1: tuple[int, int], xy2: tuple[int, int], right_click: bool = False, dry: bool = False) -> None

Draw a line (with the current brush).

Parameters:

Name	Type	Description	Default
xy1	tuple[int, int]	start position as (x, y)	required
xy2	tuple[int, int]	end position as (x, y)	required
right_click	bool	True to emulate right click, False to emulate left click. Default is False	False
dry	bool	True for dry mode	False

Source code in pytvpaint/george/grg_base.py

def tv_line(
    xy1: tuple[int, int],
    xy2: tuple[int, int],
    right_click: bool = False,
    dry: bool = False,
) -> None:
    """Draw a line (with the current brush).

    Args:
        xy1: start position as (x, y)
        xy2: end position as (x, y)
        right_click: True to emulate right click, False to emulate left click. Default is False
        dry: True for dry mode
    """
    args = [
        *xy1,
        *xy2,
        bool(right_click),
        bool(dry),
    ]
    send_cmd("tv_Line", *args)

tv_text(text: str, x: int, y: int, use_b_pen: bool = False) -> None

Write text in a layer instance.

Parameters:

Name	Type	Description	Default
text	str	text to write	required
x	int	text x position	required
y	int	text y position	required
use_b_pen	bool	True will use b pen, False will use A pen	False

Source code in pytvpaint/george/grg_base.py

def tv_text(text: str, x: int, y: int, use_b_pen: bool = False) -> None:
    """Write text in a layer instance.

    Args:
        text: text to write
        x: text x position
        y: text y position
        use_b_pen: True will use b pen, False will use A pen
    """
    send_cmd("tv_Text", x, y, int(use_b_pen), text)

tv_text_brush(text: str) -> None

Set the text for the text brush.

Parameters:

Name	Type	Description	Default
text	str	text to write	required

Source code in pytvpaint/george/grg_base.py

def tv_text_brush(text: str) -> None:
    """Set the text for the text brush.

    Args:
        text: text to write
    """
    send_cmd("tv_TextBrush", text)

tv_rect(tlx: float, tly: float, brx: float, bry: float, button: RectButton | None = None) -> None

Draws an unfilled rectangle.

Parameters:

Name	Type	Description	Default
tlx	float	top left x coordinate	required
tly	float	top left y coordinate	required
brx	float	bottom right x coordinate	required
bry	float	bottom right y coordinate	required
button	pytvpaint.george.grg_base.RectButton | None	use left or right click button (left draws, right erases)	None

Source code in pytvpaint/george/grg_base.py

def tv_rect(
    tlx: float,
    tly: float,
    brx: float,
    bry: float,
    button: RectButton | None = None,
) -> None:
    """Draws an unfilled rectangle.

    Args:
        tlx: top left x coordinate
        tly: top left y coordinate
        brx: bottom right x coordinate
        bry: bottom right y coordinate
        button: use left or right click button (left draws, right erases)
    """
    args: list[float] = [tlx, tly, brx, bry]
    if button:
        args.append(button.value)
    send_cmd("tv_Rect", *args)

tv_rect_fill(tlx: float, tly: float, brx: float, bry: float, grx: float = 0, gry: float = 0, erase_mode: bool = False, tool_mode: bool = False) -> None

Draws a filled rectangle.

Parameters:

Name	Type	Description	Default
tlx	float	top left x coordinate	required
tly	float	top left y coordinate	required
brx	float	bottom right x coordinate	required
bry	float	bottom right y coordinate	required
grx	float	gradient vector x	0
gry	float	gradient vector y	0
erase_mode	bool	erase drawing mode	False
tool_mode	bool	manage drawing mode	False

Source code in pytvpaint/george/grg_base.py

def tv_rect_fill(
    tlx: float,
    tly: float,
    brx: float,
    bry: float,
    grx: float = 0,
    gry: float = 0,
    erase_mode: bool = False,
    tool_mode: bool = False,
) -> None:
    """Draws a filled rectangle.

    Args:
        tlx: top left x coordinate
        tly: top left y coordinate
        brx: bottom right x coordinate
        bry: bottom right y coordinate
        grx: gradient vector x
        gry: gradient vector y
        erase_mode: erase drawing mode
        tool_mode: manage drawing mode
    """
    args: list[Any] = [tlx, tly, brx, bry, grx, gry, int(erase_mode)]
    if tool_mode:
        args.insert(0, "toolmode")
    send_cmd("tv_RectFill", *args)

tv_fast_line(x1: float, y1: float, x2: float, y2: float, r: int = 255, b: int = 255, g: int = 0, a: int = 255) -> None

Draw a line (1 pixel size and not antialiased).

Source code in pytvpaint/george/grg_base.py

def tv_fast_line(
    x1: float,
    y1: float,
    x2: float,
    y2: float,
    r: int = 255,
    b: int = 255,
    g: int = 0,
    a: int = 255,
) -> None:
    """Draw a line (1 pixel size and not antialiased)."""
    send_cmd("tv_fastline", x1, y1, x2, y2, r, g, b, a)