# Source code for knitout_interpreter.knitout_operations.Knitout_Line

    """Base class for Knitout Lines of code"""
    from __future__ import annotations

    from virtual_knitting_machine.Knitting_Machine import Knitting_Machine

    class Knitout_Line:
        """General class for lines of knitout."""
        _Lines_Made = 0

        def __init__(self, comment: str | None, interrupts_carriage_pass: bool = False) -> None:
            Knitout_Line._Lines_Made += 1
            self._creation_time: int = Knitout_Line._Lines_Made
            self.comment: str | None = comment
            self.original_line_number: int | None = None
            self.follow_comments: list[Knitout_Comment_Line] = []
            self._interrupts_carriage_pass: bool = interrupts_carriage_pass

        @property
        def interrupts_carriage_pass(self) -> bool:
            """Check if this line interrupts a carriage pass.

            Returns:
                True if this type of line interrupts a carriage pass, False if it
                is only used for comments or setting information.
            """
            return self._interrupts_carriage_pass

        def add_follow_comment(self, comment_line: str) -> None:
            """Add a comment line to comments that follow this line.

            Args:
                comment_line: The comment text to add.
            """
            self.follow_comments.append(Knitout_Comment_Line(comment_line))

        @property
        def has_comment(self) -> bool:
            """Check if this line has a comment.

            Returns:
                True if comment is present.
            """
            return self.comment is not None

        @property
        def comment_str(self) -> str:
            """Get the comment as a formatted string.

            Returns:
                The comment formatted as a string with appropriate formatting.
            """
            if not self.has_comment:
                return "\n"
            else:
                return f";{self.comment}\n"

        def execute(self, machine_state: Knitting_Machine) -> bool:
            """Execute the instruction on the machine state.

            Args:
                machine_state: The knitting machine state to update.

            Returns:
                True if the process completes an update.
            """
            return False

        def __str__(self) -> str:
            return self.comment_str

        @property
        def injected(self) -> bool:
            """Check if instruction was marked as injected.

            Returns:
                True if instruction was marked as injected by a negative line number.
            """
            return self.original_line_number is not None and self.original_line_number < 0

        def id_str(self) -> str:
            """Get string representation with original line number if present.

            Returns:
                String with original line number added if present.
            """
            if self.original_line_number is not None:
                return f"{self.original_line_number}:{self}"[:-1]
            else:
                return str(self)[-1:]

        def __repr__(self) -> str:
            if self.original_line_number is not None:
                return self.id_str()
            else:
                return str(self)

        # def __eq__(self, other):
        #     return str(self) == str(other)

        def __lt__(self, other: Knitout_Line) -> bool:
            if self.original_line_number is None:
                if other.original_line_number is None:
                    return False
                else:
                    return True
            elif other.original_line_number is None:
                return False
            else:
                return bool(self.original_line_number < other.original_line_number)

        def __hash__(self) -> int:
            return hash(self._creation_time)

    class Knitout_Version_Line(Knitout_Line):
        """Represents a knitout version specification line."""

        def __init__(self, version: int = 2, comment: None | str = None):
            """Initialize a version line.

            Args:
                version: The knitout version number. Defaults to 2.
                comment: Optional comment for the version line.
            """
            super().__init__(comment, interrupts_carriage_pass=False)
            self.version: int = version

        def __str__(self) -> str:
            return f";!knitout-{self.version}{self.comment_str}"

    class Knitout_Comment_Line(Knitout_Line):
        """Represents a comment line in knitout."""

        def __init__(self, comment: None | str | Knitout_Line):
            """Initialize a comment line.

            Args:
                comment: The comment text, or a Knitout_Line to convert to a comment.
            """
            if isinstance(comment, Knitout_Line):
                if isinstance(comment, Knitout_Comment_Line):
                    comment = str(Knitout_Comment_Line.comment_str)
                else:
                    comment = f"No-Op:\t{comment}"
            super().__init__(comment, interrupts_carriage_pass=False)

        def execute(self, machine_state: Knitting_Machine) -> bool:
            return True