selfie_lib.PerCharacterEscaper.PerCharacterEscaper Class Reference

Public Member Functions
	__init__ (self, int escape_code_point, list[int] escaped_code_points, list[int] escaped_by_code_points)
str	escape (self, str input_string)
str	unescape (self, str input_string)
"PerCharacterEscaper"	self_escape (cls, str escape_policy)
"PerCharacterEscaper"	specified_escape (cls, str escape_policy)

Detailed Description

Definition at line 1 of file PerCharacterEscaper.py.

Constructor & Destructor Documentation

__init__()

selfie_lib.PerCharacterEscaper.PerCharacterEscaper.__init__	(		self,
		int	escape_code_point,
		list[int]	escaped_code_points,
		list[int]	escaped_by_code_points
	)

Definition at line 2 of file PerCharacterEscaper.py.

    ):
        self.__escape_code_point: int = escape_code_point
        self.__escaped_code_points: list[int] = escaped_code_points
        self.__escaped_by_code_points: list[int] = escaped_by_code_points
 

Member Function Documentation

escape()

str selfie_lib.PerCharacterEscaper.PerCharacterEscaper.escape	(		self,
		str	input_string
	)

Definition at line 23 of file PerCharacterEscaper.py.

    def escape(self, input_string: str) -> str:
        no_escapes: int = self.__first_offset_needing_escape(input_string)
        if no_escapes == -1:
            return input_string
        else:
            result: list[str] = []
            result.append(input_string[:no_escapes])
            for char in input_string[no_escapes:]:
                codepoint: int = ord(char)
                if codepoint in self.__escaped_code_points:
                    idx: int = self.__escaped_code_points.index(codepoint)
                    result.append(chr(self.__escape_code_point))
                    result.append(chr(self.__escaped_by_code_points[idx]))
                else:
                    result.append(char)
            return "".join(result)
 

self_escape()

"PerCharacterEscaper" selfie_lib.PerCharacterEscaper.PerCharacterEscaper.self_escape	(		cls,
		str	escape_policy
	)

Definition at line 75 of file PerCharacterEscaper.py.

    def self_escape(cls, escape_policy: str) -> "PerCharacterEscaper":
        code_points: list[int] = [ord(c) for c in escape_policy]
        escape_code_point: int = code_points[0]
        return cls(escape_code_point, code_points, code_points)
 

specified_escape()

"PerCharacterEscaper" selfie_lib.PerCharacterEscaper.PerCharacterEscaper.specified_escape	(		cls,
		str	escape_policy
	)

Definition at line 81 of file PerCharacterEscaper.py.

    def specified_escape(cls, escape_policy: str) -> "PerCharacterEscaper":
        code_points: list[int] = [ord(c) for c in escape_policy]
        if len(code_points) % 2 != 0:
            raise ValueError(
                "Escape policy string must have an even number of characters."
            )
        escape_code_point: int = code_points[0]
        escaped_code_points: list[int] = code_points[0::2]
        escaped_by_code_points: list[int] = code_points[1::2]
        return cls(escape_code_point, escaped_code_points, escaped_by_code_points)

unescape()

str selfie_lib.PerCharacterEscaper.PerCharacterEscaper.unescape	(		self,
		str	input_string
	)

Definition at line 40 of file PerCharacterEscaper.py.

    def unescape(self, input_string: str) -> str:
        if input_string.endswith(
            chr(self.__escape_code_point)
        ) and not input_string.endswith(chr(self.__escape_code_point) * 2):
            raise ValueError(
                f"Escape character '{chr(self.__escape_code_point)}' can't be the last character in a string."
            )
 
        no_escapes: int = self.__first_offset_needing_escape(input_string)
        if no_escapes == -1:
            return input_string
        else:
            result: list[str] = [input_string[:no_escapes]]
            skip_next: bool = False
            for i in range(no_escapes, len(input_string)):
                if skip_next:
                    skip_next = False
                    continue
                codepoint: int = ord(input_string[i])
                if codepoint == self.__escape_code_point and (i + 1) < len(
                    input_string
                ):
                    next_codepoint: int = ord(input_string[i + 1])
                    if next_codepoint in self.__escaped_by_code_points:
                        idx: int = self.__escaped_by_code_points.index(next_codepoint)
                        result.append(chr(self.__escaped_code_points[idx]))
                        skip_next = True
                    else:
                        result.append(input_string[i + 1])
                        skip_next = True
                else:
                    result.append(chr(codepoint))
            return "".join(result)
 

---

The documentation for this class was generated from the following file:

• selfie-lib/selfie_lib/PerCharacterEscaper.py