eric: comparison src/eric7/Utilities/__init_

-:411df92e881f
+:3b34efa2857c
 # -*- coding: utf-8 -*-
-# Copyright (c) 2003 - 2023 Detlev Offenbach <detlev@die-offenbachs.de>
+# Copyright (c) 2003 - 2024 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Package implementing various functions/classes needed everywhere within eric.
 """
 ):
 """
 Module function to raise a SyntaxError for a SyntaxWarning.
 @param message warning object
+@type Class
 @param category type object of the warning
-@param filename name of the file causing the warning (string)
+@type SyntaxWarning
-@param lineno line number causing the warning (integer)
+@param filename name of the file causing the warning
+@type str
+@param lineno line number causing the warning
+@type int
 @param file file to write the warning message to (ignored)
+@type file
 @param line line causing the warning (ignored)
-@raise err exception of type SyntaxError
+@type int
+@exception err exception of type SyntaxError
 """
 if category is SyntaxWarning:
 err = SyntaxError(str(message))
 err.filename = filename
 err.lineno = lineno
 def __init__(self, coding):
 """
 Constructor
-@param coding coding to include in the message (string)
+@param coding coding to include in the message
+@type str
 """
 self.errorMessage = QCoreApplication.translate(
 "CodingError", "The coding '{0}' is wrong for the given text."
 ).format(coding)
 def __repr__(self):
 """
 Special method returning a representation of the exception.
 @return string representing the error message
+@rtype str
 """
 return str(self.errorMessage)
 def __str__(self):
 """
 Special method returning a string representation of the exception.
 @return string representing the error message
+@rtype str
 """
 return str(self.errorMessage)
 def get_codingBytes(text):
 """
 Function to get the coding of a bytes text.
-@param text bytes text to inspect (bytes)
+@param text bytes text to inspect
+@type bytes
 @return coding string
+@rtype str
 """
 lines = text.splitlines()
 for coding in codingBytes_regexps:
 coding_re = coding[1]
 head = lines[: coding[0]]
 def get_coding(text):
 """
 Function to get the coding of a text.
-@param text text to inspect (string)
+@param text text to inspect
+@type str
 @return coding string
+@rtype str
 """
 lines = text.splitlines()
 for coding in coding_regexps:
 coding_re = coding[1]
 head = lines[: coding[0]]
 def readEncodedFile(filename):
 """
 Function to read a file and decode its contents into proper text.
-@param filename name of the file to read (string)
+@param filename name of the file to read
-@return tuple of decoded text and encoding (string, string)
+@type str
+@return tuple of decoded text and encoding
+@rtype tuple of (str, str)
 """
 with open(filename, "rb") as f:
 text = f.read()
 return decode(text)
 def readEncodedFileWithHash(filename):
 """
 Function to read a file, calculate a hash value and decode its contents
 into proper text.
-@param filename name of the file to read (string)
+@param filename name of the file to read
-@return tuple of decoded text, encoding and hash value (string, string,
+@type str
-string)
+@return tuple of decoded text, encoding and hash value
+@rtype tuple of (str, str, str)
 """
 with open(filename, "rb") as f:
 text = f.read()
 hashStr = str(
 QCryptographicHash.hash(
 def decode(text):
 """
 Function to decode some byte text into a string.
-@param text byte text to decode (bytes)
+@param text byte text to decode
-@return tuple of decoded text and encoding (string, string)
+@type bytes
+@return tuple of decoded text and encoding
+@rtype tuple of (str, str)
 """
 with contextlib.suppress(UnicodeError, LookupError):
 if text.startswith(BOM_UTF8):
 # UTF-8 with BOM
 return str(text[len(BOM_UTF8) :], "utf-8"), "utf-8-bom"
 def readEncodedFileWithEncoding(filename, encoding):
 """
 Function to read a file and decode its contents into proper text.
-@param filename name of the file to read (string)
+@param filename name of the file to read
-@param encoding encoding to be used to read the file (string)
+@type str
-@return tuple of decoded text and encoding (string, string)
+@param encoding encoding to be used to read the file
+@type str
+@return tuple of decoded text and encoding
+@rtype tuple of (str, str)
 """
 with open(filename, "rb") as f:
 text = f.read()
 if encoding:
 with contextlib.suppress(UnicodeError, LookupError):
 def decodeString(text):
 """
 Function to decode a string containing Unicode encoded characters.
-@param text text containing encoded chars (string)
+@param text text containing encoded chars
-@return decoded text (string)
+@type str
+@return decoded text
+@rtype str
 """
 buf = b""
 index = 0
 while index < len(text):
 if text[index] == "\\":
 def decodeBytes(buffer):
 """
 Function to decode some byte text into a string.
-@param buffer byte buffer to decode (bytes)
+@param buffer byte buffer to decode
-@return decoded text (string)
+@type bytes
+@return decoded text
+@rtype str
 """
 # try UTF with BOM
 with contextlib.suppress(UnicodeError, LookupError):
 if buffer.startswith(BOM_UTF8):
 # UTF-8 with BOM
 def readStringFromStream(stream):
 """
 Module function to read a string from the given stream.
-@param stream data stream opened for reading (QDataStream)
+@param stream data stream opened for reading
-@return string read from the stream (string)
+@type QDataStream
+@return string read from the stream
+@rtype str
 """
 data = stream.readString()
 if data is None:
 data = b""
 return data.decode("utf-8")
 def normalizeCode(codestring):
 """
 Function to normalize the given code.
-@param codestring code to be normalized (string)
+@param codestring code to be normalized
-@return normalized code (string)
+@type str
+@return normalized code
+@rtype str
 """
 codestring = codestring.replace("\r\n", "\n").replace("\r", "\n")
 if codestring and codestring[-1] != "\n":
 codestring += "\n"
 def escape_entities(m, escmap=_escape_map):
 """
 Function to encode html entities.
 @param m the match object
+@type re.Match
 @param escmap the map of entities to encode
-@return the converted text (string)
+@type dict
+@return the converted text
+@rtype str
 """
 char = m.group()
 text = escmap.get(char)
 if text is None:
 text = "&#{0:d};".format(ord(char))
 def html_encode(text, pattern=_escape):
 """
 Function to correctly encode a text for html.
-@param text text to be encoded (string)
+@param text text to be encoded
-@param pattern search pattern for text to be encoded (string)
+@type str
-@return the encoded text (string)
+@param pattern search pattern for text to be encoded
+@type str
+@return the encoded text
+@rtype str
 """
 if not text:
 return ""
 text = pattern.sub(escape_entities, text)
 return text
 def escape_uentities(m):
 """
 Function to encode html entities.
 @param m the match object
-@return the converted text (string)
+@type re.Match
+@return the converted text
+@rtype str
 """
 char = m.group()
 text = "&#{0:d};".format(ord(char))
 return text
 def html_uencode(text, pattern=_uescape):
 """
 Function to correctly encode a unicode text for html.
-@param text text to be encoded (string)
+@param text text to be encoded
-@param pattern search pattern for text to be encoded (string)
+@type str
-@return the encoded text (string)
+@param pattern search pattern for text to be encoded
+@type str
+@return the encoded text
+@rtype str
 """
 if not text:
 return ""
 text = pattern.sub(escape_uentities, text)
 return text
 def unescape_uentities(m):
 """
 Function to decode html entities.
 @param m the match object
-@return the converted text (string)
+@type re.Match
+@return the converted text
+@rtype str
 """
 char = m.group()
 ordinal = int(char[2:-1])
 return chr(ordinal)
 def html_udecode(text, pattern=_uunescape):
 """
 Function to correctly decode a html text to a unicode text.
-@param text text to be decoded (string)
+@param text text to be decoded
-@param pattern search pattern for text to be decoded (string)
+@type str
-@return the decoded text (string)
+@param pattern search pattern for text to be decoded
+@type str
+@return the decoded text
+@rtype str
 """
 if not text:
 return ""
 text = pattern.sub(unescape_uentities, text)
 return text
 def convertLineEnds(text, eol):
 """
 Function to convert the end of line characters.
-@param text text to be converted (string)
+@param text text to be converted
-@param eol new eol setting (string)
+@type str
-@return text with converted eols (string)
+@param eol new eol setting
+@type str
+@return text with converted eols
+@rtype str
 """
 if eol == "\r\n":
 regexp = re.compile(r"""(\r(?!\n)|(?<!\r)\n)""")
 return regexp.sub("\r\n", text)
 elif eol == "\n":
 def linesep():
 """
 Function to return the line separator used by the editor.
-@return line separator used by the editor (string)
+@return line separator used by the editor
+@rtype str
 """
 eolMode = Preferences.getEditor("EOLMode")
 if eolMode == QsciScintilla.EolMode.EolUnix:
 return "\n"
 elif eolMode == QsciScintilla.EolMode.EolMac:
 is assumed to be a string. If a key does not contain a '='
 character, it is assumed to be a boolean flag. Flags are expected
 at the very end of a file. The search is ended, if a line without
 the 'eflag:' marker is found.
-@param text text to be scanned (string)
+@param text text to be scanned
+@type str
 @return dictionary of string, boolean, complex, float and int
+@rtype dict
 """
 flags = {}
 lines = text.rstrip().splitlines() if isinstance(text, str) else text
 for line in reversed(lines):
 try:
 def extractFlagsFromFile(filename):
 """
 Function to extract eric specific flags out of the given file.
-@param filename name of the file to be scanned (string)
+@param filename name of the file to be scanned
+@type str
 @return dictionary of string, boolean, complex, float and int
+@rtype dict
 """
 try:
 source, encoding = readEncodedFile(filename)
 except (OSError, UnicodeError):
 return {}
 def extractLineFlags(line, startComment="#", endComment="", flagsLine=False):
 """
 Function to extract flags starting and ending with '__' from a line
 comment.
-@param line line to extract flags from (string)
+@param line line to extract flags from
-@param startComment string identifying the start of the comment (string)
+@type str
-@param endComment string identifying the end of a comment (string)
+@param startComment string identifying the start of the comment
-@param flagsLine flag indicating to check for a flags only line (bool)
+@type str
-@return list containing the extracted flags (list of strings)
+@param endComment string identifying the end of a comment
+@type str
+@param flagsLine flag indicating to check for a flags only line
+@type bool
+@return list containing the extracted flags
+@rtype list of str
 """
 flags = []
 if not flagsLine or (flagsLine and line.strip().startswith(startComment)):
 pos = line.rfind(startComment)
 def getPercentReplacementHelp():
 """
 Function to get the help text for the supported %-codes.
-@returns help text (string)
+@return help text
+@rtype str
 """
 return QCoreApplication.translate(
 "Utilities",
 """<p>You may use %-codes as placeholders in the string."""
 """ Supported codes are:"""
 match = rx.search(txt)
 if match is None:
 return -1
 else:
 return match.start()
+def unslash(txt):
+"""
+Function to convert a string containing escape codes to an escaped string.
+@param txt string to be converted
+@type str
+@return converted string containing escape codes
+@rtype str
+"""
+s = []
+index = 0
+while index < len(txt):
+c = txt[index]
+if c == "\\" and index + 1 < len(txt):
+index += 1
+c = txt[index]
+if c == "a":
+o = "\a"
+elif c == "b":
+o = "\b"
+elif c == "f":
+o = "\f"
+elif c == "n":
+o = "\n"
+elif c == "r":
+o = "\r"
+elif c == "t":
+o = "\t"
+elif c == "v":
+o = "\v"
+elif c in "01234567":
+# octal
+oc = c
+if index + 1 < len(txt) and txt[index + 1] in "01234567":
+index += 1
+oc += txt[index]
+if index + 1 < len(txt) and txt[index + 1] in "01234567":
+index += 1
+oc += txt[index]
+o = chr(int(oc, base=8))
+elif c.lower() == "x":
+val = 0
+if index + 1 < len(txt) and txt[index + 1] in "0123456789abcdefABCDEF":
+index += 1
+hx = txt[index]
+if (
+index + 1 < len(txt)
+and txt[index + 1] in "0123456789abcdefABCDEF"
+):
+index += 1
+hx += txt[index]
+val = int(hx, base=16)
+o = chr(val)
+else:
+o = c
+else:
+o = c
+s.append(o)
+index += 1
+return "".join(s)
+_slashmap = {i: hex(i).replace("0x", "\\x") for i in range(7)}
+_slashmap.update(
+{
+7: "\\a",
+8: "\\b",
+9: "\\t",
+10: "\\n",
+11: "\\v",
+12: "\\f",
+13: "\\r",
+}
+)
+_slashmap.update({i: hex(i).replace("0x", "\\x") for i in range(14, 32)})
+_slashmap.update({i: hex(i).replace("0x", "\\x") for i in range(127, 160)})
+def slash(txt):
+"""
+Function to convert an escaped string to a string containing escape codes.
+Note: This is the reverse of 'unslash()'.
+@param txt string to be converted
+@type str
+@return converted string containing escaped escape codes
+@rtype str
+"""
+return txt.translate(_slashmap)
 ###############################################################################
 ## Other utility functions below
 ###############################################################################
 versions = {}
 for pinfo in pm.getPluginInfos():
 versions[pinfo["module_name"]] = pinfo["version"]
 info.append("Plugins Version Numbers:")
-for pluginModuleName in sorted(versions.keys()):
+for pluginModuleName in sorted(versions):
 info.append(
 "  {0} {1}".format(pluginModuleName, versions[pluginModuleName])
 )
 return linesep.join(info)

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Utilities/init.py

src/eric7/Utilities/init.py

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Utilities/__init__.py

src/eric7/Utilities/__init__.py

comparison: src/eric7/Utilities/init.py

src/eric7/Utilities/init.py