bolt-native-macros 0.2.3__tar.gz

bolt_native_macros-0.2.3/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.3
+Name: bolt-native-macros
+Version: 0.2.3
+Summary: Add your description here
+Requires-Dist: beet>=0.112.2
+Requires-Dist: bolt>=0.49.2
+Requires-Dist: mecha>=0.101.0
+Requires-Dist: bolt-expressions>=0.17.0 ; extra == 'bolt-expressions'
+Requires-Python: >=3.12
+Provides-Extra: bolt-expressions
+Description-Content-Type: text/markdown
+

bolt_native_macros-0.2.3/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "bolt-native-macros"
+version = "0.2.3"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "beet>=0.112.2",
+    "bolt>=0.49.2",
+    "mecha>=0.101.0",
+]
+
+[project.optional-dependencies]
+bolt-expressions = [
+    "bolt-expressions>=0.17.0",
+]
+
+[dependency-groups]
+dev = [
+    "lectern>=0.34.0",
+    "pytest>=9.0.2",
+    "pytest-insta>=0.4.1",
+    "python-semantic-release>=9.21.0",
+    "ruff>=0.14.13",
+]
+
+[tool.semantic_release]
+major_on_zero = false
+build_command = "uv build"
+
+version_variables = ["src/bolt_native_macros/__init__.py:__version__"]
+version_toml = ["pyproject.toml:project.version"]
+commit_author = "github-actions <action@github.com>"
+
+[tool.semantic_release.publish]
+# This ensures it uses the build_command defined above
+dist_glob_patterns = ["dist/*"]
+upload_to_vcs_release = true
+
+[build-system]
+requires = ["uv_build>=0.9.26,<0.10.0"]
+build-backend = "uv_build"

bolt_native_macros-0.2.3/src/bolt_native_macros/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "0.2.3"
+
+from .plugin import beet_default as beet_default

bolt_native_macros-0.2.3/src/bolt_native_macros/ast.py

@@ -0,0 +1,97 @@
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+from beet.core.utils import required_field
+from mecha import AstGreedy, AstMessage, AstNbtValue, AstNode, AstString, AstWord
+
+from .typing import MacroRepresentation, MacroTag
+
+__all__ = [
+    "AstMacroArgument",
+    "AstMacroNbtArgument",
+    "AstMacroCoordinateArgument",
+    "AstMacroNbtPathKeyArgument",
+    "AstMacroNbtPathArgument",
+    "AstMacroRange",
+    "AstMacroStringWrapper",
+    "AstNbtValueWithMacro",
+    "AstStringWithMacro",
+    "AstGreedyWithMacro",
+    "AstWordWithMacro",
+    "AstMessageWithMacro",
+]
+
+
+@dataclass(frozen=True, slots=True)
+class AstMacroArgument(AstNode, MacroRepresentation):
+    name: str = required_field()
+    parser: str | None = required_field()
+
+
+@dataclass(frozen=True, slots=True)
+class AstMacroNbtArgument(AstMacroArgument):
+    def evaluate(self):
+        return MacroTag(self.name, self.parser)
+
+
+@dataclass(frozen=True, slots=True)
+class AstMacroCoordinateArgument(AstMacroArgument):
+    type: Literal["absolute", "local", "relative"] = required_field()
+
+
+@dataclass(frozen=True, slots=True)
+class AstMacroNbtPathKeyArgument(AstMacroArgument): ...
+
+
+@dataclass(frozen=True, slots=True)
+class AstMacroNbtPathArgument(AstMacroArgument): ...
+
+
+@dataclass(frozen=True, slots=True)
+class AstMacroExpression(AstMacroArgument): ...
+
+
+@dataclass(frozen=True, slots=True)
+class AstMacroRange(AstNode):
+    min: int | float | AstMacroArgument | None = field(default=None)
+    max: int | float | AstMacroArgument | None = field(default=None)
+
+
+@dataclass(frozen=True, slots=True)
+class AstMacroStringWrapper[N](AstNode):
+    child: N = required_field()
+
+
+@dataclass(frozen=True, slots=True)
+class AstNbtValueWithMacro(AstNbtValue, MacroRepresentation):
+    @classmethod
+    def from_value(cls, value: Any) -> "AstNbtValueWithMacro":
+        return cls(value=value)
+
+
+@dataclass(frozen=True, slots=True)
+class AstStringWithMacro(AstString, MacroRepresentation):
+    @classmethod
+    def from_value(cls, value: Any) -> "AstStringWithMacro":
+        return AstStringWithMacro(value=str(value))
+
+
+@dataclass(frozen=True, slots=True)
+class AstGreedyWithMacro(AstGreedy, MacroRepresentation):
+    @classmethod
+    def from_value(cls, value: Any) -> "AstGreedyWithMacro":
+        return cls(value=AstGreedy.from_value(value).value)
+
+
+@dataclass(frozen=True, slots=True)
+class AstWordWithMacro(AstWord, MacroRepresentation):
+    @classmethod
+    def from_value(cls, value: Any) -> "AstWordWithMacro":
+        return cls(value=AstWord.from_value(value).value)
+
+
+@dataclass(frozen=True, slots=True)
+class AstMessageWithMacro(AstMessage, MacroRepresentation):
+    @classmethod
+    def from_value(cls, value: Any) -> "AstMessageWithMacro":
+        return cls(fragments=AstMessage.from_value(value).fragments)

bolt_native_macros-0.2.3/src/bolt_native_macros/codegen.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass
+from typing import Generator, List, Optional
+
+from bolt import Accumulator, visit_generic, visit_single
+from mecha import AstNode, Visitor, rule
+
+from .ast import AstMacroArgument, AstMacroExpression, AstMacroStringWrapper
+from .typing import MacroTag, StringWithMacro
+
+
+def ast_to_macro(macro: AstMacroArgument):
+    return MacroTag(macro.name, macro.parser)
+
+
+def make_macro_string():
+    """
+    Returns the type `StringWithMacro`, this is to add the type to the scope w/o making it globally accessible.
+
+    Kind of hacky but works well
+    """
+    return StringWithMacro
+
+
+@dataclass
+class MacroCodegen(Visitor):
+    @rule(AstMacroExpression)
+    def macro(
+        self, node: AstMacroExpression, acc: Accumulator
+    ) -> Generator[AstNode, Optional[List[str]], Optional[List[str]]]:
+        # This allows for macros to be used as literals
+        result = yield from visit_generic(node, acc)
+
+        if result is None:
+            result = acc.make_ref(node)
+
+        result = acc.helper(ast_to_macro.__name__, result)
+
+        return [result]
+
+    @rule(AstMacroStringWrapper)
+    def wrapper(
+        self, node: AstMacroStringWrapper, acc: Accumulator
+    ) -> Generator[AstNode, Optional[List[str]], Optional[List[str]]]:
+        # Codegen the underlying child and get its result
+        child = yield from visit_single(node.child, required=True)
+
+        # Create a variable and assign it to a new instance of StringWithMacro
+        result = acc.make_variable()
+        # make_macro_string returns the **type** StringWithMacro, you must manually create the instance afterwards
+        acc.statement(f"{result} = {acc.helper(make_macro_string.__name__)}({child})")
+
+        return [result]

bolt_native_macros-0.2.3/src/bolt_native_macros/parse.py

@@ -0,0 +1,248 @@
+from dataclasses import dataclass
+from typing import Any, List, cast
+
+from bolt import AstInterpolation
+from mecha import (
+    NUMBER_PATTERN,
+    AlternativeParser,
+    AstChildren,
+    AstMacroLineVariable,
+    AstNbtPath,
+    AstNbtPathKey,
+    NbtPathParser,
+    Parser,
+    delegate,
+)
+from mecha.utils import string_to_number
+from tokenstream import InvalidSyntax, TokenStream, set_location
+
+from .ast import (
+    AstMacroArgument,
+    AstMacroCoordinateArgument,
+    AstMacroNbtPathArgument,
+    AstMacroNbtPathKeyArgument,
+    AstMacroRange,
+)
+
+
+@dataclass
+class MacroParser:
+    """
+    Used to parse typed_macro's and create the proper AstNode's
+    """
+
+    parser: str | tuple[str, ...]
+    node_type: type[AstMacroArgument]
+
+    def __call__(self, stream: TokenStream):
+        macro: AstMacroArgument = delegate("typed_macro", stream)
+
+        if macro.parser:
+            # Implements type checking where it makes sense, this helps to prevent unintended macro injections
+            if isinstance(self.parser, str) and macro.parser != self.parser:
+                raise ValueError(
+                    f"Invalid macro type, received {macro.parser} expected {self.parser}"
+                )
+            elif macro.parser not in self.parser:
+                raise ValueError(
+                    f"Invalid macro type, received {macro.parser} expected one of {', '.join(self.parser)}"
+                )
+
+        parser = macro.parser
+
+        # If there was no parser just use one of the intended ones for this MacroParser
+        if isinstance(self.parser, tuple) and parser is None:
+            parser = self.parser[0]
+        elif isinstance(self.parser, str):
+            parser = self.parser
+
+        # Creates the proper instance of node_type
+        if not isinstance(macro, self.node_type):
+            return self.node_type(name=macro.name, parser=parser)
+
+        return macro
+
+
+@dataclass
+class MacroNbtPathParser(NbtPathParser):
+    """Parser for nbt paths."""
+
+    def __call__(self, stream: TokenStream) -> AstNbtPath:
+        components: List[Any] = []
+
+        with stream.syntax(
+            dot=r"\.",
+            curly=r"\{|\}",
+            bracket=r"\[|\]",
+            quoted_string=r'"(?:\\.|[^\\\n])*?"' "|" r"'(?:\\.|[^\\\n])*?'",
+            string=r"(?:[0-9a-z_\-]+:)?[a-zA-Z0-9_+-]+",
+        ):
+            components.extend(self.parse_modifiers(stream))
+
+            while not components or stream.get("dot"):
+                with stream.checkpoint() as commit:
+                    macro: AstMacroArgument = delegate("typed_macro", stream)
+
+                    if not macro.parser or macro.parser == "string":
+                        components.append(
+                            set_location(
+                                AstMacroNbtPathKeyArgument(
+                                    name=macro.name, parser="string"
+                                ),
+                                macro,
+                            )
+                        )
+                    elif macro.parser == "nbt":
+                        components.append(
+                            set_location(
+                                AstMacroNbtPathArgument(name=macro.name, parser="nbt"),
+                                macro,
+                            )
+                        )
+
+                    commit()
+
+                if commit.rollback:
+                    quoted_string, string = stream.expect("quoted_string", "string")
+
+                    if quoted_string:
+                        component_node = AstNbtPathKey(
+                            value=self.quote_helper.unquote_string(quoted_string),
+                        )
+                        components.append(set_location(component_node, quoted_string))
+                    elif string:
+                        component_node = AstNbtPathKey(value=string.value)
+                        components.append(set_location(component_node, string))
+
+                components.extend(self.parse_modifiers(stream))
+
+        if not components:
+            raise stream.emit_error(InvalidSyntax("Empty nbt path not allowed."))
+
+        node = AstNbtPath(components=AstChildren(components))
+        return set_location(node, components[0], components[-1])
+
+
+class MacroRangeParser:
+    def get_bound(self, stream: TokenStream) -> int | float | AstMacroArgument | None:
+        if number := stream.get("number"):
+            return string_to_number(number.value)
+
+        with stream.checkpoint() as commit:
+            macro: AstMacroArgument = delegate("typed_macro", stream)
+
+            if macro.parser and macro.parser != "numeric":
+                raise ValueError(
+                    f"Invalid macro type, received {macro.parser} expected numeric"
+                )
+
+            commit()
+
+        if not commit.rollback:
+            return macro
+
+        return None
+
+    def __call__(self, stream: TokenStream):
+        with stream.syntax(range=r"\.\.", number=NUMBER_PATTERN):
+            lower_bound = self.get_bound(stream)
+            range = stream.get("range")
+            upper_bound = self.get_bound(stream)
+
+        return set_location(
+            AstMacroRange(min=lower_bound, max=upper_bound),
+            lower_bound or range or upper_bound,
+            upper_bound or range or lower_bound,
+        )
+
+
+def macro(
+    parsers: dict[str, Parser],
+    type: str | tuple[str],
+    priority=False,
+    node_type: type[AstMacroArgument] = AstMacroArgument,
+):
+    """
+    Creates the proper AlternativeParser
+
+    :param parsers: The current set of parsers from mecha
+    :type parsers: dict[str, Parser]
+    :param type: The parser to create an alternative for
+    :type type: str | tuple[str]
+    :param priority: Should a macro be checked for before the original parser is used
+    :param node_type: The kind of node to be created by the parser
+    :type node_type: type[AstMacroArgument]
+    """
+    parser_type = type
+    if isinstance(type, tuple):
+        parser_type = type[0]
+
+    if not priority:
+        return AlternativeParser(
+            [parsers[cast(str, parser_type)], MacroParser(type, node_type)]
+        )
+    return AlternativeParser(
+        [MacroParser(type, node_type), parsers[cast(str, parser_type)]]
+    )
+
+
+def parse_typed_macro(stream: TokenStream):
+    """
+    Parses macros with a parser type
+    Ex: $(foo: numeric)
+
+    :param stream: The instance of TokenStream
+    :type stream: TokenStream
+    """
+    with stream.syntax(
+        open_variable=r"\$\(", close_variable=r"\)", parser=r"\w+", colon=r":\s*"
+    ):
+        open_variable = stream.expect("open_variable")
+        node: AstMacroLineVariable | AstInterpolation = delegate(
+            "macro_line_variable", stream
+        )
+
+        parser = None
+        if isinstance(node, AstMacroLineVariable):
+            name = node.value
+
+            if stream.get("colon"):
+                parser = stream.expect("parser").value
+
+        closed_variable = stream.expect("close_variable")
+    return set_location(
+        AstMacroArgument(name=name, parser=parser), open_variable, closed_variable
+    )
+
+
+def parse_coordinate(stream: TokenStream):
+    """
+    Parses coordinates with support for macros
+
+    :param stream: The TokenStream instance
+    :type stream: TokenStream
+    """
+    with stream.syntax(modifier="[~^]"):
+        modifier_token = stream.get("modifier")
+
+        modifier = "absolute"
+
+        if modifier_token and modifier_token.value == "~":
+            modifier = "relative"
+        elif modifier_token and modifier_token.value == "^":
+            modifier = "local"
+
+        macro: AstMacroArgument = delegate("typed_macro", stream)
+
+        if macro.parser and macro.parser != "numeric":
+            raise ValueError(
+                f"Invalid macro type, received {macro.parser} expected numeric"
+            )
+
+        return set_location(
+            AstMacroCoordinateArgument(
+                name=macro.name, type=modifier, parser="numeric"
+            ),
+            modifier_token or macro.location,
+            macro.end_location,
+        )

bolt_native_macros-0.2.3/src/bolt_native_macros/patches.py

@@ -0,0 +1,27 @@
+from typing import Any
+
+from nbtlib import Serializer as NbtSerializer
+
+from .serialize import serialize_macro
+from .typing import MacroTag
+
+
+def apply_patches():
+    NbtSerializer.serialize_macro = serialize_macro  # type: ignore
+
+    try:
+        import bolt_expressions.typing
+
+        convert_tag = bolt_expressions.typing.convert_tag
+
+        def convert_tag_with_macro(value: Any):
+            match value:
+                case MacroTag():
+                    return value
+                case _:
+                    return convert_tag(value)
+
+        bolt_expressions.typing.convert_tag = convert_tag_with_macro
+
+    except ImportError:
+        ...

bolt_native_macros-0.2.3/src/bolt_native_macros/plugin.py

@@ -0,0 +1,87 @@
+from beet import Context
+from bolt import Runtime
+from mecha import AlternativeParser, Mecha, Parser
+
+from .ast import (
+    AstGreedyWithMacro,
+    AstMacroExpression,
+    AstMacroNbtArgument,
+    AstMessageWithMacro,
+    AstNbtValueWithMacro,
+    AstStringWithMacro,
+    AstWordWithMacro,
+)
+from .codegen import MacroCodegen, ast_to_macro, make_macro_string
+from .parse import (
+    MacroNbtPathParser,
+    MacroParser,
+    MacroRangeParser,
+    macro,
+    parse_coordinate,
+    parse_typed_macro,
+)
+from .patches import apply_patches
+from .serialize import CommandSerializer, MacroConverter, MacroMutator
+
+def get_parsers(parsers: dict[str, Parser]):
+    parse_nbt: Parser = parsers["nbt"]
+
+    def make_nbt_parser(parser: Parser):
+        return AlternativeParser(
+            [MacroParser(("nbt", "string"), AstMacroNbtArgument), parser]
+        )
+
+    new_parsers = {
+        "typed_macro": parse_typed_macro,
+        "bool": macro(parsers, "bool"),
+        "numeric": macro(parsers, "numeric"),
+        "coordinate": AlternativeParser([parsers["coordinate"], parse_coordinate]),
+        "time": macro(parsers, "time"),
+        "word": macro(parsers, "word", priority=True),
+        "phrase": macro(parsers, "phrase", priority=True),
+        "greedy": macro(parsers, "greedy", priority=True),
+        "entity": macro(parsers, "entity", priority=True),
+        "nbt": make_nbt_parser(parsers["nbt"]),
+        "nbt_compound_entry": make_nbt_parser(parsers["nbt_compound_entry"]),
+        "nbt_list_or_array_element": make_nbt_parser(
+            parsers["nbt_list_or_array_element"]
+        ),
+        "nbt_compound": make_nbt_parser(parsers["nbt_compound"]),
+        "nbt_path": AlternativeParser(
+            [parsers["nbt_path"], MacroNbtPathParser(nbt_compound_parser=parse_nbt)]
+        ),
+        "range": AlternativeParser([parsers["range"], MacroRangeParser()]),
+        "bolt:literal": macro(parsers, "bolt:literal", node_type=AstMacroExpression),
+    }
+
+    return new_parsers
+
+
+conversions = {
+    "interpolate_phrase": AstStringWithMacro,
+    "interpolate_word": AstWordWithMacro,
+    "interpolate_greedy": AstGreedyWithMacro,
+    "interpolate_nbt": AstNbtValueWithMacro,
+    "interpolate_message": AstMessageWithMacro,
+}
+
+
+def beet_default(ctx: Context):
+    apply_patches()
+
+    mc = ctx.inject(Mecha)
+
+    mc.spec.parsers.update(get_parsers(mc.spec.parsers))
+    mc.serialize.extend(CommandSerializer(spec=mc.spec))
+    mc.steps.insert(0, MacroMutator())
+
+    runtime = ctx.inject(Runtime)
+
+    runtime.modules.codegen.extend(MacroCodegen())
+    runtime.helpers[ast_to_macro.__name__] = ast_to_macro
+    runtime.helpers[make_macro_string.__name__] = make_macro_string
+
+    for conversion, node_type in conversions.items():
+        runtime.helpers[conversion] = MacroConverter(
+            runtime.helpers[conversion], node_type
+        )

bolt_native_macros-0.2.3/src/bolt_native_macros/serialize.py

@@ -0,0 +1,172 @@
+from dataclasses import dataclass
+from typing import Any, Callable, List
+
+from beet.core.utils import required_field
+from bolt import AstFormatString
+from mecha import (
+    AstCommand,
+    AstNbtPath,
+    AstNbtPathKey,
+    AstNode,
+    CommandSpec,
+    MutatingReducer,
+    Visitor,
+    rule,
+)
+from mecha.utils import number_to_string
+from nbtlib import Serializer as NbtSerializer
+from tokenstream import set_location
+
+from .ast import (
+    AstMacroArgument,
+    AstMacroCoordinateArgument,
+    AstMacroNbtArgument,
+    AstMacroNbtPathArgument,
+    AstMacroNbtPathKeyArgument,
+    AstMacroRange,
+    AstMacroStringWrapper,
+)
+from .typing import MacroRepresentation, MacroTag, StringWithMacro
+
+
+def serialize_macro(_self: NbtSerializer, tag: MacroTag):
+    if tag.parser == "string":
+        return f'"$({tag.name})"'
+
+    return f"$({tag.name})"
+
+
+@dataclass
+class MacroConverter:
+    """
+    Used to convert interpolated strings with contain macros to the proper AstXWithMacro nodes
+    """
+
+    base_converter: Callable[[Any, AstNode], AstNode]
+    node_type: type
+
+    def __call__(self, obj: Any, node: AstNode) -> AstNode:
+        if isinstance(obj, StringWithMacro):
+            return self.node_type.from_value(obj)
+        return self.base_converter(obj, node)
+
+
+@dataclass
+class CommandSerializer(Visitor):
+    spec: CommandSpec = required_field()
+
+    @rule(AstCommand)
+    def command(self, node: AstCommand, result: list[str]):
+        prototype = self.spec.prototypes[node.identifier]
+        argument_index = 0
+
+        sep = ""
+
+        start_index = 0
+        # Scan backwards until we find the start of the current line
+        for i in range(len(result) - 1, -1, -1):
+            if result[i] == "\n":
+                start_index = i + 1
+                break
+
+        for token in prototype.signature:
+            result.append(sep)
+            sep = " "
+
+            # If token is a string then we can move on, literals can't contain macros
+            if isinstance(token, str):
+                result.append(token)
+            else:
+                argument = node.arguments[argument_index]
+
+                # Scan the argument for any MacroRepresentations
+                for child in argument.walk():
+                    if isinstance(child, MacroRepresentation):
+                        result[start_index] = "$"
+                        break
+
+                yield argument
+                argument_index += 1
+
+        if result[start_index] == "$":
+            return
+
+        for i in range(start_index, len(result)):
+            if result[i] == "$(" and result[i + 2] == ")":
+                result[start_index] = "$"
+                break
+
+    def default(self, argument: AstMacroArgument, result: list[str]):
+        string = argument.parser == "string"
+        if string:
+            result.append('"')
+
+        result.append("$(")
+        result.append(argument.name)
+        result.append(")")
+
+        if string:
+            result.append('"')
+
+    @rule(AstMacroArgument, AstMacroNbtPathArgument, AstMacroNbtArgument)
+    def macro(self, argument: AstMacroArgument, result: list[str]):
+        self.default(argument, result)
+
+    @rule(AstMacroCoordinateArgument)
+    def coordinate(self, argument: AstMacroCoordinateArgument, result: list[str]):
+        if argument.type == "local":
+            result.append("^")
+        elif argument.type == "relative":
+            result.append("~")
+
+        self.default(argument, result)
+
+    @rule(AstMacroNbtPathKeyArgument)
+    def macro_path_key(self, argument: AstMacroNbtPathKeyArgument, result: list[str]):
+        self.default(argument, result)
+
+    @rule(AstNbtPath)
+    def nbt_path(self, node: AstNbtPath, result: List[str]):
+        sep = ""
+        for component in node.components:
+            if isinstance(
+                component,
+                (AstNbtPathKey, AstMacroNbtPathKeyArgument, AstMacroNbtPathArgument),
+            ):
+                result.append(sep)
+            sep = "."
+            yield component
+
+    @rule(AstMacroRange)
+    def range(self, node: AstMacroRange, result: list[str]):
+        if node.min == node.max and node.min is not None:
+            if isinstance(node.min, AstMacroArgument):
+                yield node.min
+            else:
+                result.append(number_to_string(node.min))
+        else:
+            if node.min is not None:
+                if isinstance(node.min, AstMacroArgument):
+                    yield node.min
+                else:
+                    result.append(number_to_string(node.min))
+
+            result.append("..")
+
+            if node.max is not None:
+                if isinstance(node.max, AstMacroArgument):
+                    yield node.max
+                else:
+                    result.append(number_to_string(node.max))
+
+
+@dataclass
+class MacroMutator(MutatingReducer):
+    @rule(AstFormatString)
+    def format_string(self, node: AstFormatString):
+        if any(map(lambda v: isinstance(v, AstMacroArgument), node.values)):
+            return set_location(
+                AstMacroStringWrapper(child=node), node.location, node.end_location
+            )
+
+        return node

bolt_native_macros-0.2.3/src/bolt_native_macros/typing.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+
+from beet.core.utils import required_field
+from nbtlib import Base
+
+
+class MacroRepresentation: ...
+
+
+class StringWithMacro(str): ...
+
+
+@dataclass
+class MacroTag(Base):
+    name: str = required_field()
+    parser: str | None = required_field()
+
+    def __post_init__(self):
+        self.serializer = "macro"
+
+    def __str__(self):
+        return f"$({self.name})"