| from __future__ import annotations |
|
|
| from functools import lru_cache |
| from typing import Iterable, NoReturn, Sequence, cast |
|
|
| import rich.repr |
|
|
| from .._border import BorderValue, normalize_border_value |
| from .._duration import _duration_as_seconds |
| from .._easing import EASING |
| from ..color import Color, ColorParseError |
| from ..geometry import Spacing, SpacingDimensions, clamp |
| from ..suggestions import get_suggestion |
| from ._error_tools import friendly_list |
| from ._help_renderables import HelpText |
| from ._help_text import ( |
| align_help_text, |
| border_property_help_text, |
| color_property_help_text, |
| dock_property_help_text, |
| fractional_property_help_text, |
| integer_help_text, |
| layout_property_help_text, |
| offset_property_help_text, |
| offset_single_axis_help_text, |
| property_invalid_value_help_text, |
| scalar_help_text, |
| scrollbar_size_property_help_text, |
| scrollbar_size_single_axis_help_text, |
| spacing_invalid_value_help_text, |
| spacing_wrong_number_of_values_help_text, |
| string_enum_help_text, |
| style_flags_property_help_text, |
| table_rows_or_columns_help_text, |
| text_align_help_text, |
| ) |
| from .constants import ( |
| VALID_ALIGN_HORIZONTAL, |
| VALID_ALIGN_VERTICAL, |
| VALID_BORDER, |
| VALID_BOX_SIZING, |
| VALID_DISPLAY, |
| VALID_EDGE, |
| VALID_OVERFLOW, |
| VALID_SCROLLBAR_GUTTER, |
| VALID_STYLE_FLAGS, |
| VALID_TEXT_ALIGN, |
| VALID_VISIBILITY, |
| ) |
| from .errors import DeclarationError, StyleValueError |
| from .model import Declaration |
| from .scalar import ( |
| Scalar, |
| ScalarError, |
| ScalarOffset, |
| ScalarParseError, |
| Unit, |
| percentage_string_to_float, |
| ) |
| from .styles import Styles |
| from .tokenize import Token |
| from .transition import Transition |
| from .types import BoxSizing, Display, Edge, EdgeType, Overflow, Visibility |
|
|
|
|
| def _join_tokens(tokens: Iterable[Token], joiner: str = "") -> str: |
| """Convert tokens into a string by joining their values |
| |
| Args: |
| tokens (Iterable[Token]): Tokens to join |
| joiner (str): String to join on, defaults to "" |
| |
| Returns: |
| str: The tokens, joined together to form a string. |
| """ |
| return joiner.join(token.value for token in tokens) |
|
|
|
|
| class StylesBuilder: |
| """ |
| The StylesBuilder object takes tokens parsed from the CSS and converts |
| to the appropriate internal types. |
| """ |
|
|
| def __init__(self) -> None: |
| self.styles = Styles() |
|
|
| def __rich_repr__(self) -> rich.repr.Result: |
| yield "styles", self.styles |
|
|
| def __repr__(self) -> str: |
| return "StylesBuilder()" |
|
|
| def error(self, name: str, token: Token, message: str | HelpText) -> NoReturn: |
| raise DeclarationError(name, token, message) |
|
|
| def add_declaration(self, declaration: Declaration) -> None: |
| if not declaration.tokens: |
| return |
| rule_name = declaration.name.replace("-", "_") |
| process_method = getattr(self, f"process_{rule_name}", None) |
|
|
| if process_method is None: |
| suggested_property_name = self._get_suggested_property_name_for_rule( |
| declaration.name |
| ) |
| self.error( |
| declaration.name, |
| declaration.token, |
| property_invalid_value_help_text( |
| declaration.name, |
| "css", |
| suggested_property_name=suggested_property_name, |
| ), |
| ) |
| return |
|
|
| tokens = declaration.tokens |
|
|
| important = tokens[-1].name == "important" |
| if important: |
| tokens = tokens[:-1] |
| self.styles.important.add(rule_name) |
| try: |
| process_method(declaration.name, tokens) |
| except DeclarationError: |
| raise |
| except Exception as error: |
| self.error(declaration.name, declaration.token, str(error)) |
|
|
| @lru_cache(maxsize=None) |
| def _get_processable_rule_names(self) -> Sequence[str]: |
| """ |
| Returns the list of CSS properties we can manage - |
| i.e. the ones for which we have a `process_[property name]` method |
| |
| Returns: |
| Sequence[str]: All the "Python-ised" CSS property names this class can handle. |
| |
| Example: ("width", "background", "offset_x", ...) |
| """ |
| return [attr[8:] for attr in dir(self) if attr.startswith("process_")] |
|
|
| def _process_enum_multiple( |
| self, name: str, tokens: list[Token], valid_values: set[str], count: int |
| ) -> tuple[str, ...]: |
| """Generic code to process a declaration with two enumerations, like overflow: auto auto""" |
| if len(tokens) > count or not tokens: |
| self.error(name, tokens[0], f"expected 1 to {count} tokens here") |
| results: list[str] = [] |
| append = results.append |
| for token in tokens: |
| token_name, value, _, _, location, _ = token |
| if token_name != "token": |
| self.error( |
| name, |
| token, |
| f"invalid token {value!r}; expected {friendly_list(valid_values)}", |
| ) |
| append(value) |
|
|
| short_results = results[:] |
|
|
| while len(results) < count: |
| results.extend(short_results) |
| results = results[:count] |
|
|
| return tuple(results) |
|
|
| def _process_enum( |
| self, name: str, tokens: list[Token], valid_values: set[str] |
| ) -> str: |
| """Process a declaration that expects an enum. |
| |
| Args: |
| name (str): Name of declaration. |
| tokens (list[Token]): Tokens from parser. |
| valid_values (list[str]): A set of valid values. |
| |
| Returns: |
| bool: True if the value is valid or False if it is invalid (also generates an error) |
| """ |
|
|
| if len(tokens) != 1: |
| string_enum_help_text(name, valid_values=list(valid_values), context="css"), |
|
|
| token = tokens[0] |
| token_name, value, _, _, location, _ = token |
| if token_name != "token": |
| self.error( |
| name, |
| token, |
| string_enum_help_text( |
| name, valid_values=list(valid_values), context="css" |
| ), |
| ) |
| if value not in valid_values: |
| self.error( |
| name, |
| token, |
| string_enum_help_text( |
| name, valid_values=list(valid_values), context="css" |
| ), |
| ) |
| return value |
|
|
| def process_display(self, name: str, tokens: list[Token]) -> None: |
| for token in tokens: |
| name, value, _, _, location, _ = token |
|
|
| if name == "token": |
| value = value.lower() |
| if value in VALID_DISPLAY: |
| self.styles._rules["display"] = cast(Display, value) |
| else: |
| self.error( |
| name, |
| token, |
| string_enum_help_text( |
| "display", valid_values=list(VALID_DISPLAY), context="css" |
| ), |
| ) |
| else: |
| self.error( |
| name, |
| token, |
| string_enum_help_text( |
| "display", valid_values=list(VALID_DISPLAY), context="css" |
| ), |
| ) |
|
|
| def _process_scalar(self, name: str, tokens: list[Token]) -> None: |
| def scalar_error(): |
| self.error( |
| name, tokens[0], scalar_help_text(property_name=name, context="css") |
| ) |
|
|
| if not tokens: |
| return |
| if len(tokens) == 1: |
| try: |
| self.styles._rules[name.replace("-", "_")] = Scalar.parse( |
| tokens[0].value |
| ) |
| except ScalarParseError: |
| scalar_error() |
| else: |
| scalar_error() |
|
|
| def process_box_sizing(self, name: str, tokens: list[Token]) -> None: |
| for token in tokens: |
| name, value, _, _, location, _ = token |
|
|
| if name == "token": |
| value = value.lower() |
| if value in VALID_BOX_SIZING: |
| self.styles._rules["box_sizing"] = cast(BoxSizing, value) |
| else: |
| self.error( |
| name, |
| token, |
| string_enum_help_text( |
| "box-sizing", |
| valid_values=list(VALID_BOX_SIZING), |
| context="css", |
| ), |
| ) |
| else: |
| self.error( |
| name, |
| token, |
| string_enum_help_text( |
| "box-sizing", valid_values=list(VALID_BOX_SIZING), context="css" |
| ), |
| ) |
|
|
| def process_width(self, name: str, tokens: list[Token]) -> None: |
| self._process_scalar(name, tokens) |
|
|
| def process_height(self, name: str, tokens: list[Token]) -> None: |
| self._process_scalar(name, tokens) |
|
|
| def process_min_width(self, name: str, tokens: list[Token]) -> None: |
| self._process_scalar(name, tokens) |
|
|
| def process_min_height(self, name: str, tokens: list[Token]) -> None: |
| self._process_scalar(name, tokens) |
|
|
| def process_max_width(self, name: str, tokens: list[Token]) -> None: |
| self._process_scalar(name, tokens) |
|
|
| def process_max_height(self, name: str, tokens: list[Token]) -> None: |
| self._process_scalar(name, tokens) |
|
|
| def process_overflow(self, name: str, tokens: list[Token]) -> None: |
| rules = self.styles._rules |
| overflow_x, overflow_y = self._process_enum_multiple( |
| name, tokens, VALID_OVERFLOW, 2 |
| ) |
| rules["overflow_x"] = cast(Overflow, overflow_x) |
| rules["overflow_y"] = cast(Overflow, overflow_y) |
|
|
| def process_overflow_x(self, name: str, tokens: list[Token]) -> None: |
| self.styles._rules["overflow_x"] = cast( |
| Overflow, self._process_enum(name, tokens, VALID_OVERFLOW) |
| ) |
|
|
| def process_overflow_y(self, name: str, tokens: list[Token]) -> None: |
| self.styles._rules["overflow_y"] = cast( |
| Overflow, self._process_enum(name, tokens, VALID_OVERFLOW) |
| ) |
|
|
| def process_visibility(self, name: str, tokens: list[Token]) -> None: |
| for token in tokens: |
| name, value, _, _, location, _ = token |
| if name == "token": |
| value = value.lower() |
| if value in VALID_VISIBILITY: |
| self.styles._rules["visibility"] = cast(Visibility, value) |
| else: |
| self.error( |
| name, |
| token, |
| string_enum_help_text( |
| "visibility", |
| valid_values=list(VALID_VISIBILITY), |
| context="css", |
| ), |
| ) |
| else: |
| string_enum_help_text( |
| "visibility", valid_values=list(VALID_VISIBILITY), context="css" |
| ) |
|
|
| def _process_fractional(self, name: str, tokens: list[Token]) -> None: |
| if not tokens: |
| return |
| token = tokens[0] |
| error = False |
| if len(tokens) != 1: |
| error = True |
| else: |
| token_name = token.name |
| value = token.value |
| rule_name = name.replace("-", "_") |
| if token_name == "scalar" and value.endswith("%"): |
| try: |
| text_opacity = percentage_string_to_float(value) |
| self.styles.set_rule(rule_name, text_opacity) |
| except ValueError: |
| error = True |
| elif token_name == "number": |
| try: |
| text_opacity = clamp(float(value), 0, 1) |
| self.styles.set_rule(rule_name, text_opacity) |
| except ValueError: |
| error = True |
| else: |
| error = True |
|
|
| if error: |
| self.error(name, token, fractional_property_help_text(name, context="css")) |
|
|
| process_opacity = _process_fractional |
| process_text_opacity = _process_fractional |
|
|
| def _process_space(self, name: str, tokens: list[Token]) -> None: |
| space: list[int] = [] |
| append = space.append |
| for token in tokens: |
| token_name, value, _, _, _, _ = token |
| if token_name == "number": |
| try: |
| append(int(value)) |
| except ValueError: |
| self.error( |
| name, |
| token, |
| spacing_invalid_value_help_text(name, context="css"), |
| ) |
| else: |
| self.error( |
| name, token, spacing_invalid_value_help_text(name, context="css") |
| ) |
| if len(space) not in (1, 2, 4): |
| self.error( |
| name, |
| tokens[0], |
| spacing_wrong_number_of_values_help_text( |
| name, num_values_supplied=len(space), context="css" |
| ), |
| ) |
| self.styles._rules[name] = Spacing.unpack(cast(SpacingDimensions, tuple(space))) |
|
|
| def _process_space_partial(self, name: str, tokens: list[Token]) -> None: |
| """Process granular margin / padding declarations.""" |
| if len(tokens) != 1: |
| self.error( |
| name, tokens[0], spacing_invalid_value_help_text(name, context="css") |
| ) |
|
|
| _EDGE_SPACING_MAP = {"top": 0, "right": 1, "bottom": 2, "left": 3} |
| token = tokens[0] |
| token_name, value, _, _, _, _ = token |
| if token_name == "number": |
| space = int(value) |
| else: |
| self.error( |
| name, token, spacing_invalid_value_help_text(name, context="css") |
| ) |
| style_name, _, edge = name.replace("-", "_").partition("_") |
|
|
| current_spacing = cast( |
| "tuple[int, int, int, int]", |
| self.styles._rules.get(style_name, (0, 0, 0, 0)), |
| ) |
|
|
| spacing_list = list(current_spacing) |
| spacing_list[_EDGE_SPACING_MAP[edge]] = space |
|
|
| self.styles._rules[style_name] = Spacing(*spacing_list) |
|
|
| process_padding = _process_space |
| process_margin = _process_space |
|
|
| process_margin_top = _process_space_partial |
| process_margin_right = _process_space_partial |
| process_margin_bottom = _process_space_partial |
| process_margin_left = _process_space_partial |
|
|
| process_padding_top = _process_space_partial |
| process_padding_right = _process_space_partial |
| process_padding_bottom = _process_space_partial |
| process_padding_left = _process_space_partial |
|
|
| def _parse_border(self, name: str, tokens: list[Token]) -> BorderValue: |
|
|
| border_type: EdgeType = "solid" |
| border_color = Color(0, 255, 0) |
|
|
| def border_value_error(): |
| self.error(name, token, border_property_help_text(name, context="css")) |
|
|
| for token in tokens: |
| token_name, value, _, _, _, _ = token |
| if token_name == "token": |
| if value in VALID_BORDER: |
| border_type = value |
| else: |
| try: |
| border_color = Color.parse(value) |
| except ColorParseError: |
| border_value_error() |
|
|
| elif token_name == "color": |
| try: |
| border_color = Color.parse(value) |
| except ColorParseError: |
| border_value_error() |
|
|
| else: |
| border_value_error() |
|
|
| return normalize_border_value((border_type, border_color)) |
|
|
| def _process_border_edge(self, edge: str, name: str, tokens: list[Token]) -> None: |
| border = self._parse_border(name, tokens) |
| self.styles._rules[f"border_{edge}"] = border |
|
|
| def process_border(self, name: str, tokens: list[Token]) -> None: |
| border = self._parse_border(name, tokens) |
| rules = self.styles._rules |
| rules["border_top"] = rules["border_right"] = border |
| rules["border_bottom"] = rules["border_left"] = border |
|
|
| def process_border_top(self, name: str, tokens: list[Token]) -> None: |
| self._process_border_edge("top", name, tokens) |
|
|
| def process_border_right(self, name: str, tokens: list[Token]) -> None: |
| self._process_border_edge("right", name, tokens) |
|
|
| def process_border_bottom(self, name: str, tokens: list[Token]) -> None: |
| self._process_border_edge("bottom", name, tokens) |
|
|
| def process_border_left(self, name: str, tokens: list[Token]) -> None: |
| self._process_border_edge("left", name, tokens) |
|
|
| def _process_outline(self, edge: str, name: str, tokens: list[Token]) -> None: |
| border = self._parse_border(name, tokens) |
| self.styles._rules[f"outline_{edge}"] = border |
|
|
| def process_outline(self, name: str, tokens: list[Token]) -> None: |
| border = self._parse_border(name, tokens) |
| rules = self.styles._rules |
| rules["outline_top"] = rules["outline_right"] = border |
| rules["outline_bottom"] = rules["outline_left"] = border |
|
|
| def process_outline_top(self, name: str, tokens: list[Token]) -> None: |
| self._process_outline("top", name, tokens) |
|
|
| def process_parse_border_right(self, name: str, tokens: list[Token]) -> None: |
| self._process_outline("right", name, tokens) |
|
|
| def process_outline_bottom(self, name: str, tokens: list[Token]) -> None: |
| self._process_outline("bottom", name, tokens) |
|
|
| def process_outline_left(self, name: str, tokens: list[Token]) -> None: |
| self._process_outline("left", name, tokens) |
|
|
| def process_offset(self, name: str, tokens: list[Token]) -> None: |
| def offset_error(name: str, token: Token) -> None: |
| self.error(name, token, offset_property_help_text(context="css")) |
|
|
| if not tokens: |
| return |
| if len(tokens) != 2: |
| offset_error(name, tokens[0]) |
| else: |
| token1, token2 = tokens |
|
|
| if token1.name not in ("scalar", "number"): |
| offset_error(name, token1) |
| if token2.name not in ("scalar", "number"): |
| offset_error(name, token2) |
|
|
| scalar_x = Scalar.parse(token1.value, Unit.WIDTH) |
| scalar_y = Scalar.parse(token2.value, Unit.HEIGHT) |
| self.styles._rules["offset"] = ScalarOffset(scalar_x, scalar_y) |
|
|
| def process_offset_x(self, name: str, tokens: list[Token]) -> None: |
| if not tokens: |
| return |
| if len(tokens) != 1: |
| self.error(name, tokens[0], offset_single_axis_help_text(name)) |
| else: |
| token = tokens[0] |
| if token.name not in ("scalar", "number"): |
| self.error(name, token, offset_single_axis_help_text(name)) |
| x = Scalar.parse(token.value, Unit.WIDTH) |
| y = self.styles.offset.y |
| self.styles._rules["offset"] = ScalarOffset(x, y) |
|
|
| def process_offset_y(self, name: str, tokens: list[Token]) -> None: |
| if not tokens: |
| return |
| if len(tokens) != 1: |
| self.error(name, tokens[0], offset_single_axis_help_text(name)) |
| else: |
| token = tokens[0] |
| if token.name not in ("scalar", "number"): |
| self.error(name, token, offset_single_axis_help_text(name)) |
| y = Scalar.parse(token.value, Unit.HEIGHT) |
| x = self.styles.offset.x |
| self.styles._rules["offset"] = ScalarOffset(x, y) |
|
|
| def process_layout(self, name: str, tokens: list[Token]) -> None: |
| from ..layouts.factory import MissingLayout, get_layout |
|
|
| if tokens: |
| if len(tokens) != 1: |
| self.error( |
| name, tokens[0], layout_property_help_text(name, context="css") |
| ) |
| else: |
| value = tokens[0].value |
| layout_name = value |
| try: |
| self.styles._rules["layout"] = get_layout(layout_name) |
| except MissingLayout: |
| self.error( |
| name, |
| tokens[0], |
| layout_property_help_text(name, context="css"), |
| ) |
|
|
| def process_color(self, name: str, tokens: list[Token]) -> None: |
| """Processes a simple color declaration.""" |
| name = name.replace("-", "_") |
|
|
| color: Color | None = None |
| alpha: float | None = None |
|
|
| for token in tokens: |
| if ( |
| "background" not in name |
| and token.name == "token" |
| and token.value == "auto" |
| ): |
| self.styles._rules[f"auto_{name}"] = True |
| elif token.name == "scalar": |
| alpha_scalar = Scalar.parse(token.value) |
| if alpha_scalar.unit != Unit.PERCENT: |
| self.error(name, token, "alpha must be given as a percentage.") |
| alpha = alpha_scalar.value / 100.0 |
|
|
| elif token.name in ("color", "token"): |
| try: |
| color = Color.parse(token.value) |
| except Exception as error: |
| self.error( |
| name, |
| token, |
| color_property_help_text(name, context="css", error=error), |
| ) |
| else: |
| self.error(name, token, color_property_help_text(name, context="css")) |
|
|
| if color is not None or alpha is not None: |
| if alpha is not None: |
| color = (color or Color(255, 255, 255)).with_alpha(alpha) |
| self.styles._rules[name] = color |
|
|
| process_tint = process_color |
| process_background = process_color |
| process_scrollbar_color = process_color |
| process_scrollbar_color_hover = process_color |
| process_scrollbar_color_active = process_color |
| process_scrollbar_corner_color = process_color |
| process_scrollbar_background = process_color |
| process_scrollbar_background_hover = process_color |
| process_scrollbar_background_active = process_color |
|
|
| process_link_color = process_color |
| process_link_background = process_color |
| process_hover_color = process_color |
| process_hover_background = process_color |
|
|
| def process_text_style(self, name: str, tokens: list[Token]) -> None: |
| for token in tokens: |
| value = token.value |
| if value not in VALID_STYLE_FLAGS: |
| self.error( |
| name, |
| token, |
| style_flags_property_help_text(name, value, context="css"), |
| ) |
|
|
| style_definition = " ".join(token.value for token in tokens) |
| self.styles._rules[name.replace("-", "_")] = style_definition |
|
|
| process_link_style = process_text_style |
| process_hover_style = process_text_style |
|
|
| def process_text_align(self, name: str, tokens: list[Token]) -> None: |
| """Process a text-align declaration""" |
| if not tokens: |
| return |
|
|
| if len(tokens) > 1 or tokens[0].value not in VALID_TEXT_ALIGN: |
| self.error( |
| name, |
| tokens[0], |
| text_align_help_text(), |
| ) |
|
|
| self.styles._rules["text_align"] = tokens[0].value |
|
|
| def process_dock(self, name: str, tokens: list[Token]) -> None: |
| if not tokens: |
| return |
|
|
| if len(tokens) > 1 or tokens[0].value not in VALID_EDGE: |
| self.error( |
| name, |
| tokens[0], |
| dock_property_help_text(name, context="css"), |
| ) |
|
|
| dock = tokens[0].value |
| self.styles._rules["dock"] = dock |
|
|
| def process_layer(self, name: str, tokens: list[Token]) -> None: |
| if len(tokens) > 1: |
| self.error(name, tokens[1], f"unexpected tokens in dock-edge declaration") |
| self.styles._rules["layer"] = tokens[0].value |
|
|
| def process_layers(self, name: str, tokens: list[Token]) -> None: |
| layers: list[str] = [] |
| for token in tokens: |
| if token.name != "token": |
| self.error(name, token, "{token.name} not expected here") |
| layers.append(token.value) |
| self.styles._rules["layers"] = tuple(layers) |
|
|
| def process_transition(self, name: str, tokens: list[Token]) -> None: |
| transitions: dict[str, Transition] = {} |
|
|
| def make_groups() -> Iterable[list[Token]]: |
| """Batch tokens into comma-separated groups.""" |
| group: list[Token] = [] |
| for token in tokens: |
| if token.name == "comma": |
| if group: |
| yield group |
| group = [] |
| else: |
| group.append(token) |
| if group: |
| yield group |
|
|
| valid_duration_token_names = ("duration", "number") |
| for tokens in make_groups(): |
| css_property = "" |
| duration = 1.0 |
| easing = "linear" |
| delay = 0.0 |
|
|
| try: |
| iter_tokens = iter(tokens) |
| token = next(iter_tokens) |
| if token.name != "token": |
| self.error(name, token, "expected property") |
|
|
| css_property = token.value |
| token = next(iter_tokens) |
| if token.name not in valid_duration_token_names: |
| self.error(name, token, "expected duration or number") |
| try: |
| duration = _duration_as_seconds(token.value) |
| except ScalarError as error: |
| self.error(name, token, str(error)) |
|
|
| token = next(iter_tokens) |
| if token.name != "token": |
| self.error(name, token, "easing function expected") |
|
|
| if token.value not in EASING: |
| self.error( |
| name, |
| token, |
| f"expected easing function; found {token.value!r}", |
| ) |
| easing = token.value |
|
|
| token = next(iter_tokens) |
| if token.name not in valid_duration_token_names: |
| self.error(name, token, "expected duration or number") |
| try: |
| delay = _duration_as_seconds(token.value) |
| except ScalarError as error: |
| self.error(name, token, str(error)) |
| except StopIteration: |
| pass |
| transitions[css_property] = Transition(duration, easing, delay) |
|
|
| self.styles._rules["transitions"] = transitions |
|
|
| def process_align(self, name: str, tokens: list[Token]) -> None: |
| def align_error(name, token): |
| self.error(name, token, align_help_text()) |
|
|
| if len(tokens) != 2: |
| self.error(name, tokens[0], align_help_text()) |
|
|
| token_horizontal = tokens[0] |
| token_vertical = tokens[1] |
|
|
| if token_horizontal.name != "token": |
| align_error(name, token_horizontal) |
| elif token_horizontal.value not in VALID_ALIGN_HORIZONTAL: |
| align_error(name, token_horizontal) |
|
|
| if token_vertical.name != "token": |
| align_error(name, token_vertical) |
| elif token_vertical.value not in VALID_ALIGN_VERTICAL: |
| align_error(name, token_horizontal) |
|
|
| name = name.replace("-", "_") |
| self.styles._rules[f"{name}_horizontal"] = token_horizontal.value |
| self.styles._rules[f"{name}_vertical"] = token_vertical.value |
|
|
| def process_align_horizontal(self, name: str, tokens: list[Token]) -> None: |
| try: |
| value = self._process_enum(name, tokens, VALID_ALIGN_HORIZONTAL) |
| except StyleValueError: |
| self.error( |
| name, |
| tokens[0], |
| string_enum_help_text(name, VALID_ALIGN_HORIZONTAL, context="css"), |
| ) |
| else: |
| self.styles._rules[name.replace("-", "_")] = value |
|
|
| def process_align_vertical(self, name: str, tokens: list[Token]) -> None: |
| try: |
| value = self._process_enum(name, tokens, VALID_ALIGN_VERTICAL) |
| except StyleValueError: |
| self.error( |
| name, |
| tokens[0], |
| string_enum_help_text(name, VALID_ALIGN_VERTICAL, context="css"), |
| ) |
| else: |
| self.styles._rules[name.replace("-", "_")] = value |
|
|
| process_content_align = process_align |
| process_content_align_horizontal = process_align_horizontal |
| process_content_align_vertical = process_align_vertical |
|
|
| def process_scrollbar_gutter(self, name: str, tokens: list[Token]) -> None: |
| try: |
| value = self._process_enum(name, tokens, VALID_SCROLLBAR_GUTTER) |
| except StyleValueError: |
| self.error( |
| name, |
| tokens[0], |
| string_enum_help_text(name, VALID_SCROLLBAR_GUTTER, context="css"), |
| ) |
| else: |
| self.styles._rules[name.replace("-", "_")] = value |
|
|
| def process_scrollbar_size(self, name: str, tokens: list[Token]) -> None: |
| def scrollbar_size_error(name: str, token: Token) -> None: |
| self.error(name, token, scrollbar_size_property_help_text(context="css")) |
|
|
| if not tokens: |
| return |
| if len(tokens) != 2: |
| scrollbar_size_error(name, tokens[0]) |
| else: |
| token1, token2 = tokens |
|
|
| if token1.name != "number" or not token1.value.isdigit(): |
| scrollbar_size_error(name, token1) |
| if token2.name != "number" or not token2.value.isdigit(): |
| scrollbar_size_error(name, token2) |
|
|
| horizontal = int(token1.value) |
| if horizontal == 0: |
| scrollbar_size_error(name, token1) |
| vertical = int(token2.value) |
| if vertical == 0: |
| scrollbar_size_error(name, token2) |
| self.styles._rules["scrollbar_size_horizontal"] = horizontal |
| self.styles._rules["scrollbar_size_vertical"] = vertical |
|
|
| def process_scrollbar_size_vertical(self, name: str, tokens: list[Token]) -> None: |
| if not tokens: |
| return |
| if len(tokens) != 1: |
| self.error(name, tokens[0], scrollbar_size_single_axis_help_text(name)) |
| else: |
| token = tokens[0] |
| if token.name != "number" or not token.value.isdigit(): |
| self.error(name, token, scrollbar_size_single_axis_help_text(name)) |
| value = int(token.value) |
| if value == 0: |
| self.error(name, token, scrollbar_size_single_axis_help_text(name)) |
| self.styles._rules["scrollbar_size_vertical"] = value |
|
|
| def process_scrollbar_size_horizontal(self, name: str, tokens: list[Token]) -> None: |
| if not tokens: |
| return |
| if len(tokens) != 1: |
| self.error(name, tokens[0], scrollbar_size_single_axis_help_text(name)) |
| else: |
| token = tokens[0] |
| if token.name != "number" or not token.value.isdigit(): |
| self.error(name, token, scrollbar_size_single_axis_help_text(name)) |
| value = int(token.value) |
| if value == 0: |
| self.error(name, token, scrollbar_size_single_axis_help_text(name)) |
| self.styles._rules["scrollbar_size_horizontal"] = value |
|
|
| def _process_grid_rows_or_columns(self, name: str, tokens: list[Token]) -> None: |
| scalars: list[Scalar] = [] |
| for token in tokens: |
| if token.name == "number": |
| scalars.append(Scalar.from_number(float(token.value))) |
| elif token.name == "scalar": |
| scalars.append( |
| Scalar.parse( |
| token.value, |
| percent_unit=Unit.WIDTH if name == "rows" else Unit.HEIGHT, |
| ) |
| ) |
| else: |
| self.error( |
| name, |
| token, |
| table_rows_or_columns_help_text(name, token.value, context="css"), |
| ) |
| self.styles._rules[name.replace("-", "_")] = scalars |
|
|
| process_grid_rows = _process_grid_rows_or_columns |
| process_grid_columns = _process_grid_rows_or_columns |
|
|
| def _process_integer(self, name: str, tokens: list[Token]) -> None: |
| if not tokens: |
| return |
| if len(tokens) != 1: |
| self.error(name, tokens[0], integer_help_text(name)) |
| else: |
| token = tokens[0] |
| if token.name != "number" or not token.value.isdigit(): |
| self.error(name, token, integer_help_text(name)) |
| value = int(token.value) |
| if value == 0: |
| self.error(name, token, integer_help_text(name)) |
| self.styles._rules[name.replace("-", "_")] = value |
|
|
| process_grid_gutter_horizontal = _process_integer |
| process_grid_gutter_vertical = _process_integer |
| process_column_span = _process_integer |
| process_row_span = _process_integer |
| process_grid_size_columns = _process_integer |
| process_grid_size_rows = _process_integer |
|
|
| def process_grid_gutter(self, name: str, tokens: list[Token]) -> None: |
| if not tokens: |
| return |
| if len(tokens) == 1: |
| token = tokens[0] |
| if token.name != "number": |
| self.error(name, token, integer_help_text(name)) |
| value = max(0, int(token.value)) |
| self.styles._rules["grid_gutter_horizontal"] = value |
| self.styles._rules["grid_gutter_vertical"] = value |
|
|
| elif len(tokens) == 2: |
| token = tokens[0] |
| if token.name != "number": |
| self.error(name, token, integer_help_text(name)) |
| value = max(0, int(token.value)) |
| self.styles._rules["grid_gutter_horizontal"] = value |
| token = tokens[1] |
| if token.name != "number": |
| self.error(name, token, integer_help_text(name)) |
| value = max(0, int(token.value)) |
| self.styles._rules["grid_gutter_vertical"] = value |
|
|
| else: |
| self.error(name, tokens[0], "expected two integers here") |
|
|
| def process_grid_size(self, name: str, tokens: list[Token]) -> None: |
| if not tokens: |
| return |
| if len(tokens) == 1: |
| token = tokens[0] |
| if token.name != "number": |
| self.error(name, token, integer_help_text(name)) |
| value = max(0, int(token.value)) |
| self.styles._rules["grid_size_columns"] = value |
| self.styles._rules["grid_size_rows"] = 0 |
|
|
| elif len(tokens) == 2: |
| token = tokens[0] |
| if token.name != "number": |
| self.error(name, token, integer_help_text(name)) |
| value = max(0, int(token.value)) |
| self.styles._rules["grid_size_columns"] = value |
| token = tokens[1] |
| if token.name != "number": |
| self.error(name, token, integer_help_text(name)) |
| value = max(0, int(token.value)) |
| self.styles._rules["grid_size_rows"] = value |
|
|
| else: |
| self.error(name, tokens[0], "expected two integers here") |
|
|
| def _get_suggested_property_name_for_rule(self, rule_name: str) -> str | None: |
| """ |
| Returns a valid CSS property "Python" name, or None if no close matches could be found. |
| |
| Args: |
| rule_name (str): An invalid "Python-ised" CSS property (i.e. "offst_x" rather than "offst-x") |
| |
| Returns: |
| str | None: The closest valid "Python-ised" CSS property. |
| Returns `None` if no close matches could be found. |
| |
| Example: returns "background" for rule_name "bkgrund", "offset_x" for "ofset_x" |
| """ |
| return get_suggestion(rule_name, self._get_processable_rule_names()) |
|
|
