selfie_lib.Literals.LiteralString Class Reference

Inheritance diagram for selfie_lib.Literals.LiteralString:

Public Member Functions
str	encode (self, str value, Language language, EscapeLeadingWhitespace encoding_policy)
str	parse (self, str string, Language language)
str	encodeMultiPython (self, str arg, EscapeLeadingWhitespace escape_leading_whitespace)
str	inline_backslashes (self, str source)
str	parseMultiPython (self, str source_with_quotes)

Protected Member Functions
str	_encodeSinglePython (self, str value)
bool	_is_control_char (self, str c)
str	_parseSinglePython (self, str source_with_quotes)
str	_unescape_python (self, str source)

Static Protected Attributes
	_char_literal_pattern = re.compile()

Detailed Description

Definition at line 68 of file Literals.py.

Member Function Documentation

_encodeSinglePython()

str selfie_lib.Literals.LiteralString._encodeSinglePython (   self, str  value  )

protected

Definition at line 93 of file Literals.py.

    def _encodeSinglePython(self, value: str) -> str:
        source = io.StringIO()
        source.write('"')
        for char in value:
            if char == "\b":
                source.write("\\b")
            elif char == "\n":
                source.write("\\n")
            elif char == "\r":
                source.write("\\r")
            elif char == "\t":
                source.write("\\t")
            elif char == '"':
                source.write('\\"')
            elif char == "\\":
                source.write("\\\\")
            elif self._is_control_char(char):
                source.write("\\u" + str(ord(char)).zfill(4))
            else:
                source.write(char)
        source.write('"')
        return source.getvalue()
 

_is_control_char()

bool selfie_lib.Literals.LiteralString._is_control_char (   self, str  c  )

protected

Definition at line 116 of file Literals.py.

    def _is_control_char(self, c: str) -> bool:
        return c in "\u0000\u001f" or c == "\u007f"
 

_parseSinglePython()

str selfie_lib.Literals.LiteralString._parseSinglePython (   self, str  source_with_quotes  )

protected

Definition at line 120 of file Literals.py.

    def _parseSinglePython(self, source_with_quotes: str) -> str:
        assert source_with_quotes.startswith('"')
        assert source_with_quotes.endswith('"')
        source = source_with_quotes[1:-1]
        to_unescape = self.inline_backslashes(source)  # changed from inline_dollar
        return self._unescape_python(to_unescape)
 

_unescape_python()

str selfie_lib.Literals.LiteralString._unescape_python (   self, str  source  )

protected

Definition at line 179 of file Literals.py.

    def _unescape_python(self, source: str) -> str:
        value = io.StringIO()
        i = 0
        while i < len(source):
            c = source[i]
            if c == "\\":
                i += 1
                c = source[i]
                if c == '"':
                    value.write('"')
                elif c == "\\":
                    value.write("\\")
                elif c == "b":
                    value.write("\b")
                elif c == "f":
                    value.write("\f")
                elif c == "n":
                    value.write("\n")
                elif c == "r":
                    value.write("\r")
                elif c == "s":
                    value.write(" ")
                elif c == "t":
                    value.write("\t")
                elif c == "u":
                    code = int(source[i + 1 : i + 5], 16)
                    value.write(chr(code))
                    i += 4
                else:
                    raise ValueError(f"Unknown escape sequence {c}")
            else:
                value.write(c)
            i += 1
        return value.getvalue()
 

encode()

str selfie_lib.Literals.LiteralString.encode	(		self,
		str	value,
		Language	language,
		EscapeLeadingWhitespace	encoding_policy
	)

Reimplemented from selfie_lib.Literals.LiteralFormat.

Definition at line 69 of file Literals.py.

    ) -> str:
        if language == Language.PYTHON:
            if "\n" not in value:
                return self._encodeSinglePython(value)
            else:
                return self.encodeMultiPython(value, encoding_policy)
        else:
            raise NotImplementedError(
                f"Encoding for language {language} is not implemented."
            )
 

encodeMultiPython()

str selfie_lib.Literals.LiteralString.encodeMultiPython	(		self,
		str	arg,
		EscapeLeadingWhitespace	escape_leading_whitespace
	)

Definition at line 127 of file Literals.py.

    ) -> str:
        escape_backslashes = arg.replace("\\", "\\\\")
        escape_triple_quotes = escape_backslashes.replace(TRIPLE_QUOTE, '\\"\\"\\"')
 
        def protect_trailing_whitespace(line: str) -> str:
            if line.endswith(" "):
                return line[:-1] + "\\u0020"
            elif line.endswith("\t"):
                return line[:-1] + "\\t"
            else:
                return line
 
        lines = escape_triple_quotes.splitlines()
        protect_whitespace = "\n".join(
            escape_leading_whitespace.escape_line(
                protect_trailing_whitespace(line), "\\u0020", "\\t"
            )
            for line in lines
        )
 
        return f"{TRIPLE_QUOTE}{protect_whitespace}{TRIPLE_QUOTE}"
 

inline_backslashes()

str selfie_lib.Literals.LiteralString.inline_backslashes	(		self,
		str	source
	)

Definition at line 153 of file Literals.py.

    def inline_backslashes(self, source: str) -> str:
        def replace_char(char_literal: str) -> str:
            if len(char_literal) == 1:
                return char_literal
            elif len(char_literal) == 2 and char_literal[0] == "\\":
                if char_literal[1] == "t":
                    return "\t"
                elif char_literal[1] == "b":
                    return "\b"
                elif char_literal[1] == "n":
                    return "\n"
                elif char_literal[1] == "r":
                    return "\r"
                elif char_literal[1] == "'":
                    return "'"
                elif char_literal[1] == "\\":
                    return "\\"
                else:
                    raise ValueError(f"Unknown character literal {char_literal}")
            else:
                raise ValueError(f"Unknown character literal {char_literal}")
 
        return self._char_literal_pattern.sub(
            lambda match: replace_char(match.group(1)), source
        )
 

parse()

str selfie_lib.Literals.LiteralString.parse	(		self,
		str	string,
		Language	language
	)

Reimplemented from selfie_lib.Literals.LiteralFormat.

Definition at line 82 of file Literals.py.

    def parse(self, string: str, language: Language) -> str:
        if language == Language.PYTHON:
            if not string.startswith(TRIPLE_QUOTE):
                return self._parseSinglePython(string)
            else:
                return self.parseMultiPython(string)
        else:
            raise NotImplementedError(
                f"Encoding for language {language} is not implemented."
            )
 

parseMultiPython()

str selfie_lib.Literals.LiteralString.parseMultiPython	(		self,
		str	source_with_quotes
	)

Definition at line 214 of file Literals.py.

    def parseMultiPython(self, source_with_quotes: str) -> str:
        assert source_with_quotes.startswith(TRIPLE_QUOTE)
        assert source_with_quotes.endswith(TRIPLE_QUOTE)
        return self._unescape_python(
            source_with_quotes[len(TRIPLE_QUOTE) : -len(TRIPLE_QUOTE)]
        )
 
 

Member Data Documentation

_char_literal_pattern

selfie_lib.Literals.LiteralString._char_literal_pattern = re.compile()

staticprotected

Definition at line 151 of file Literals.py.

---

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

• selfie-lib/selfie_lib/Literals.py