yaralyzer 1.0.6__py3-none-any.whl → 1.0.8__py3-none-any.whl

yaralyzer/encoding_detection/character_encodings.py

@@ -1,5 +1,6 @@
 """
-Constants related to character encodings
+Constants related to character encodings.
+
 * https://www.mit.edu/people/kenta/two/iso8859.html
 * https://www.utf8-chartable.de/unicode-utf8-table.pl?utf8=dec
 """
@@ -13,7 +14,7 @@ ASCII = 'ascii'
 UTF_8 = 'utf-8'
 UTF_16 = 'utf-16'
 UTF_32 = 'utf-32'
-ISO_8859_1 =  'iso-8859-1'
+ISO_8859_1 = 'iso-8859-1'
 WINDOWS_1252 = 'windows-1252'
 
 
@@ -32,39 +33,39 @@ BOMS = {
 # ASCII characters that either print nothing, put the cursor in a weird place, or (worst of all) actively
 # delete stuff you already printed
 UNPRINTABLE_ASCII = {
-    0: 'NUL',
-    1: 'SOH',  # 'StartHeading',
-    2: 'STX',  # 'StartText',
+    0: 'NUL',    # 'Null',
+    1: 'SOH',    # 'StartHeading',
+    2: 'STX',    # 'StartText',
     3: 'ETX',
-    4: 'EOT',  # End of transmission
-    5: 'ENQ',  # 'Enquiry',
-    6: 'ACK',  # 'Acknowledgement',
-    7: 'BEL',  # 'Bell',
-    8: 'BS',   # 'BackSpace',
-    #9:  'HT'  # 'HorizontalTab',
-    #10: 'LF',  # 'LineFeed',
-    11: 'VT',  # 'VerticalTab',
-    12: 'FF',  # 'FormFeed', AKA 'NewPage'
-    13: 'CR',  # 'CarriageReturn',
-    14: 'SO',  # 'ShiftOut',
-    15: 'SI',  # 'ShiftIn',
-    16: 'DLE',  # 'DataLineEscape',
-    17: 'DC1',  # DeviceControl1',
-    18: 'DC2',  # 'DeviceControl2',
-    19: 'DC3',  # 'DeviceControl3',
-    20: 'DC4',  # 'DeviceControl4',
+    4: 'EOT',    # End of transmission
+    5: 'ENQ',    # 'Enquiry',
+    6: 'ACK',    # 'Acknowledgement',
+    7: 'BEL',    # 'Bell',
+    8: 'BS',     # 'BackSpace',
+    # 9:  'HT'   # 'HorizontalTab',
+    # 10: 'LF',  # 'LineFeed',
+    11: 'VT',    # 'VerticalTab',
+    12: 'FF',    # 'FormFeed', AKA 'NewPage'
+    13: 'CR',    # 'CarriageReturn',
+    14: 'SO',    # 'ShiftOut',
+    15: 'SI',    # 'ShiftIn',
+    16: 'DLE',   # 'DataLineEscape',
+    17: 'DC1',   # DeviceControl1',
+    18: 'DC2',   # 'DeviceControl2',
+    19: 'DC3',   # 'DeviceControl3',
+    20: 'DC4',   # 'DeviceControl4',
     21: 'NAK',   # NegativeAcknowledgement',
-    22: 'SYN',  # 'SynchronousIdle',
-    23: 'ETB',  # 'EndTransmitBlock',
-    24: 'CAN',  # 'Cancel',
-    25: 'EM',  # 'EndMedium',
-    26: 'SUB',  # 'Substitute',
-    27: 'ESC',  # 'Escape',
-    28: 'FS',  # 'FileSeparator',
-    29: 'GS',  #'GroupSeparator',
-    30: 'RS',  #'RecordSeparator',
-    31: 'US',  # 'UnitSeparator',
-    127: 'DEL', # Delete
+    22: 'SYN',   # 'SynchronousIdle',
+    23: 'ETB',   # 'EndTransmitBlock',
+    24: 'CAN',   # 'Cancel',
+    25: 'EM',    # 'EndMedium',
+    26: 'SUB',   # 'Substitute',
+    27: 'ESC',   # 'Escape',
+    28: 'FS',    # 'FileSeparator',
+    29: 'GS',    # 'GroupSeparator',
+    30: 'RS',    # 'RecordSeparator',
+    31: 'US',    # 'UnitSeparator',
+    127: 'DEL',  # Delete
 }
 
 
@@ -116,12 +117,12 @@ UNPRINTABLE_UTF_8.update({
 UNPRINTABLE_WIN_1252 = UNPRINTABLE_ASCII.copy()
 
 UNPRINTABLE_WIN_1252.update({
-    129: 'HOP', # High Octet Preset
-    141: 'RLF', # Reverse Line Feed
-    143: 'SS3', # Single shift 3
-    144: 'DCS', # Device Control String
-    147: 'STS', # Set transmit state
-    160: 'NBSP',
+    129: 'HOP',   # High Octet Preset
+    141: 'RLF',   # Reverse Line Feed
+    143: 'SS3',   # Single shift 3
+    144: 'DCS',   # Device Control String
+    147: 'STS',   # Set transmit state
+    160: 'NBSP',  # Non-breaking space
 })
 
 
@@ -146,7 +147,6 @@ ENCODINGS_TO_ATTEMPT = {
     UTF_32:       None,  # UTF-16 and 32 are handled differently
     ISO_8859_1:   UNPRINTABLE_ISO_8859_1,
     WINDOWS_1252: UNPRINTABLE_WIN_1252,
-    #'utf-7':
 }
 
 SINGLE_BYTE_ENCODINGS = [

yaralyzer/encoding_detection/encoding_assessment.py

@@ -1,5 +1,5 @@
 """
-Class to smooth some of the rough edges around the dicts returned by chardet.detect_all()
+Help with chardet library.
 """
 from typing import Any, Optional
 
@@ -7,27 +7,33 @@ from rich.text import Text
 
 from yaralyzer.encoding_detection.character_encodings import ENCODING
 from yaralyzer.helpers.rich_text_helper import (DIM_COUNTRY_THRESHOLD, meter_style,
-     prefix_with_plain_text_obj)
+     prefix_with_style)
 
 CONFIDENCE = 'confidence'
 LANGUAGE = 'language'
 
 
 class EncodingAssessment:
+    """Class to smooth some of the rough edges around the dicts returned by chardet.detect_all()"""
+
     def __init__(self, assessment: dict) -> None:
+        """
+        Args:
+            assessment (dict): The dict returned by chardet.detect_all().
+        """
         self.assessment = assessment
         self.encoding = assessment[ENCODING].lower()
 
         # Shift confidence from 0-1.0 scale to 0-100.0 scale
         self.confidence = 100.0 * (self._get_dict_empty_value_as_None(CONFIDENCE) or 0.0)
-        self.confidence_text = prefix_with_plain_text_obj(f"{round(self.confidence, 1)}%", style=meter_style(self.confidence))
+        self.confidence_text = prefix_with_style(f"{round(self.confidence, 1)}%", style=meter_style(self.confidence))
 
         # Add detected language info and label if any language was detected
         self.language = self._get_dict_empty_value_as_None(LANGUAGE)
         self.set_encoding_label(self.language.title() if self.language else None)
 
     @classmethod
-    def dummy_encoding_assessment(cls, encoding) -> 'EncodingAssessment':
+    def dummy_encoding_assessment(cls, encoding: str) -> 'EncodingAssessment':
         """Generate an empty EncodingAssessment to use as a dummy when chardet gives us nothing."""
         assessment = cls({ENCODING: encoding, CONFIDENCE: 0.0})
         assessment.confidence_text = Text('none', 'no_attempt')

yaralyzer/encoding_detection/encoding_detector.py

@@ -1,7 +1,4 @@
-"""
-Manager class to ease dealing with the chardet encoding detection library 'chardet'.
-Each instance of this class manages a chardet.detect_all() scan on a single set of bytes.
-"""
+"""EncodingDetector class for managing chardet encoding detection."""
 from operator import attrgetter
 from typing import List
 
@@ -9,7 +6,6 @@ import chardet
 from rich import box
 from rich.padding import Padding
 from rich.table import Table
-from rich.text import Text
 
 from yaralyzer.config import YaralyzerConfig
 from yaralyzer.encoding_detection.encoding_assessment import ENCODING, EncodingAssessment
@@ -19,10 +15,15 @@ CONFIDENCE_SCORE_RANGE = range(0, 101)
 
 
 class EncodingDetector:
-    # 10 as in 10%, 0.02, etc.  Encodings w/confidences below this will not be displayed in the decoded table
+    """
+    Manager class to ease dealing with the chardet encoding detection library 'chardet'.
+    Each instance of this class manages a chardet.detect_all() scan on a single set of bytes.
+    """
+
+    # Default value for encodings w/confidences below this will not be displayed in the decoded table
     force_display_threshold = 20.0
 
-    # At what chardet.detect() confidence % should we force a decode with an obscure encoding?
+    # Default value for what chardet.detect() confidence % should we force a decode with an obscure encoding.
     force_decode_threshold = 50.0
 
     def __init__(self, _bytes: bytes) -> None:
@@ -54,21 +55,23 @@ class EncodingDetector:
         self.force_display_assessments = self.assessments_above_confidence(type(self).force_display_threshold)
 
     def get_encoding_assessment(self, encoding: str) -> EncodingAssessment:
-        """If chardet produced one, return it, otherwise return a dummy node with confidence of 0"""
+        """If chardet produced one, return it, otherwise return a dummy node with confidence of 0."""
         assessment = next((r for r in self.unique_assessments if r.encoding == encoding), None)
         return assessment or EncodingAssessment.dummy_encoding_assessment(encoding)
 
     def has_enough_bytes(self) -> bool:
+        """Return true if we have enough bytes to run chardet.detect()."""
         return self.bytes_len >= YaralyzerConfig.args.min_chardet_bytes
 
     def assessments_above_confidence(self, cutoff: float) -> List[EncodingAssessment]:
+        """Return the assessments above the given confidence cutoff."""
         return [a for a in self.unique_assessments if a.confidence >= cutoff]
 
     def __rich__(self) -> Padding:
         return Padding(self.table, (0, 0, 0, 0))
 
     def _uniquify_results_and_build_table(self) -> None:
-        """Keep the highest result per encoding, ignoring the language chardet has indicated"""
+        """Keep the highest result per encoding, ignoring the language chardet has indicated."""
         already_seen_encodings = {}
 
         for i, result in enumerate(self.assessments):
@@ -83,11 +86,12 @@ class EncodingDetector:
                 self.unique_assessments.append(result)
                 already_seen_encodings[result.encoding] = result
             else:
-                log.debug(f"Skipping chardet result {result}: we already saw {already_seen_encodings[result.encoding]})")
+                log.debug(f"Skipping chardet result {result} (already saw {already_seen_encodings[result.encoding]})")
 
         self.unique_assessments.sort(key=attrgetter('confidence'), reverse=True)
 
     def _set_empty_results(self) -> None:
+        """Set empty results for when chardet can't help us."""
         self.assessments = []
         self.unique_assessments = []
         self.raw_chardet_assessments = []
@@ -96,7 +100,7 @@ class EncodingDetector:
 
 
 def _empty_chardet_results_table():
-    """Returns a fresh table"""
+    """Returns a fresh table."""
     table = Table(
         'Rank', 'Encoding', 'Confidence',
         title='chardet.detect results',
@@ -105,8 +109,8 @@ def _empty_chardet_results_table():
         style='dim',
         box=box.SIMPLE,
         show_edge=False,
-        collapse_padding=True)
+        collapse_padding=True
+    )
 
     table.columns[0].justify = 'right'
-    table.columns # TODO: ???
     return table

yaralyzer/helpers/bytes_helper.py

@@ -25,15 +25,35 @@ HEX_CHARS_PER_LINE = HEX_CHARS_PER_GROUP * HEX_GROUPS_PER_LINE
 
 
 def get_bytes_before_and_after_match(_bytes: bytes, match: re.Match, num_before=None, num_after=None) -> bytes:
-    """
-    Get all bytes from num_before the start of the sequence up until num_after the end of the sequence
-    num_before and num_after will both default to the env var/CLI options having to do with surrounding
-    bytes. If only num_before is provided then num_after will use it as a default.
+    r"""
+    Get bytes before and after a regex match within a byte sequence.
+
+    Args:
+        _bytes (bytes): The full byte sequence.
+        match (re.Match): The regex match object.
+        num_before (int, optional): Number of bytes before the match to include. Defaults to config.
+        num_after (int, optional): Number of bytes after the match to include. Defaults to either config or num_before value.
+
+    Returns:
+        bytes: The surrounding bytes including the match.
     """
     return get_bytes_surrounding_range(_bytes, match.start(), match.end(), num_before, num_after)
 
 
 def get_bytes_surrounding_range(_bytes: bytes, start_idx: int, end_idx: int, num_before=None, num_after=None) -> bytes:
+    r"""
+    Get bytes surrounding a specified range in a byte sequence.
+
+    Args:
+        _bytes (bytes): The full byte sequence.
+        start_idx (int): Start index of the range.
+        end_idx (int): End index of the range.
+        num_before (int, optional): Number of bytes before the range. Defaults to config.
+        num_after (int, optional): Number of bytes after the range. Defaults to config.
+
+    Returns:
+        bytes: The surrounding bytes including the range.
+    """
     num_after = num_after or num_before or YaralyzerConfig.args.surrounding_bytes
     num_before = num_before or YaralyzerConfig.args.surrounding_bytes
     start_idx = max(start_idx - num_before, 0)
@@ -42,7 +62,16 @@ def get_bytes_surrounding_range(_bytes: bytes, start_idx: int, end_idx: int, num
 
 
 def clean_byte_string(bytes_array: bytes) -> str:
-    """Gives you a string representation of bytes w/no cruft e.g. '\x80\nx44' instead of "b'\x80\nx44'"."""
+    r"""
+    Return a clean string representation of bytes, without Python's b'' or b"" wrappers.
+    e.g. '\x80\nx44' instead of "b'\x80\nx44'".
+
+    Args:
+        bytes_array (bytes): The bytes to convert.
+
+    Returns:
+        str: Clean string representation of the bytes.
+    """
     byte_printer = Console(file=StringIO())
     byte_printer.out(bytes_array, end='')
     bytestr = byte_printer.file.getvalue()
@@ -58,7 +87,16 @@ def clean_byte_string(bytes_array: bytes) -> str:
 
 
 def rich_text_view_of_raw_bytes(_bytes: bytes, bytes_match: BytesMatch) -> Text:
-    """Print raw bytes to a Text object, highlighing the bytes in the bytes_match BytesMatch"""
+    r"""
+    Return a rich Text object of raw bytes, highlighting the matched bytes.
+
+    Args:
+        _bytes (bytes): The full byte sequence.
+        bytes_match (BytesMatch): The BytesMatch object indicating which bytes to highlight.
+
+    Returns:
+        Text: Rich Text object with highlighted match.
+    """
     surrounding_bytes_str = clean_byte_string(_bytes)
     highlighted_bytes_str = clean_byte_string(bytes_match.bytes)
     highlighted_bytes_str_length = len(highlighted_bytes_str)
@@ -72,6 +110,16 @@ def rich_text_view_of_raw_bytes(_bytes: bytes, bytes_match: BytesMatch) -> Text:
 
 
 def hex_view_of_raw_bytes(_bytes: bytes, bytes_match: BytesMatch) -> Text:
+    r"""
+    Return a hexadecimal view of raw bytes, highlighting the matched bytes.
+
+    Args:
+        _bytes (bytes): The full byte sequence.
+        bytes_match (BytesMatch): The BytesMatch object indicating which bytes to highlight.
+
+    Returns:
+        Text: Rich Text object with highlighted match in hex view.
+    """
     hex_str = hex_text(_bytes)
     highlight_start_idx = bytes_match.highlight_start_idx * 3
     highlight_end_idx = bytes_match.highlight_end_idx * 3
@@ -81,6 +129,16 @@ def hex_view_of_raw_bytes(_bytes: bytes, bytes_match: BytesMatch) -> Text:
 
 
 def ascii_view_of_raw_bytes(_bytes: bytes, bytes_match: BytesMatch) -> Text:
+    r"""
+    Return an ASCII view of raw bytes, highlighting the matched bytes.
+
+    Args:
+        _bytes (bytes): The full byte sequence.
+        bytes_match (BytesMatch): The BytesMatch object indicating which bytes to highlight.
+
+    Returns:
+        Text: Rich Text object with highlighted match in ASCII view.
+    """
     txt = Text('', style=BYTES)
 
     for i, b in enumerate(_bytes):
@@ -113,23 +171,54 @@ def ascii_view_of_raw_bytes(_bytes: bytes, bytes_match: BytesMatch) -> Text:
 
 
 def hex_text(_bytes: bytes) -> Text:
+    r"""
+    Return a rich Text object of the hex string for the given bytes.
+
+    Args:
+        _bytes (bytes): The bytes to convert.
+
+    Returns:
+        Text: Rich Text object of the hex string.
+    """
     return Text(hex_string(_bytes), style=GREY)
 
 
 def hex_string(_bytes: bytes) -> str:
+    r"""
+    Return a hex string representation of the given bytes.
+
+    Args:
+        _bytes (bytes): The bytes to convert.
+
+    Returns:
+        str: Hex string representation of the bytes.
+    """
     return ' '.join([hex(b).removeprefix('0x').rjust(2, '0') for i, b in enumerate(_bytes)])
 
 
 def print_bytes(bytes_array: bytes, style=None) -> None:
-    """Convert bytes to a string representation and print to console"""
+    r"""
+    Print a string representation of bytes to the console.
+
+    Args:
+        bytes_array (bytes): The bytes to print.
+        style (str, optional): Style to use for printing. Defaults to 'bytes'.
+    """
     for line in bytes_array.split(NEWLINE_BYTE):
         console.print(escape(clean_byte_string(line)), style=style or 'bytes')
 
 
 def truncate_for_encoding(_bytes: bytes, encoding: str) -> bytes:
-    """
-    Truncate bytes to the a modulus of the char width of the given encoding.
-    For utf-16 this means truncate to a multiple of 2, for utf-32 to a multiple of 4.
+    r"""
+    Truncate bytes to a multiple of the character width for the given encoding.
+    For example, for utf-16 this means truncating to a multiple of 2, for utf-32 to a multiple of 4.
+
+    Args:
+        _bytes (bytes): The bytes to truncate.
+        encoding (str): The encoding to consider.
+
+    Returns:
+        bytes: Truncated bytes.
     """
     char_width = encoding_width(encoding)
     num_bytes = len(_bytes)
@@ -142,11 +231,19 @@ def truncate_for_encoding(_bytes: bytes, encoding: str) -> bytes:
 
 
 def _find_str_rep_of_bytes(surrounding_bytes_str: str, highlighted_bytes_str: str, highlighted_bytes: BytesMatch):
-    """
-    Find the position of bytes_str in surrounding_byte_str. Both args are raw text dumps of binary data.
-    Because strings are longer than bytes (stuff like '\xcc' are 4 chars when printed are one byte and the ANSI unprintables
-    include stuff like 'NegativeAcknowledgement' which is over 20 chars) they represent so we have to re-find the location to highlight the bytes
-    correctly.
+    r"""
+    Find the position of the highlighted bytes string within the surrounding bytes string.
+
+    Both arguments are string representations of binary data. This is needed because the string
+    representation of bytes can be longer than the actual bytes (e.g., '\\xcc' is 4 chars for 1 byte).
+
+    Args:
+        surrounding_bytes_str (str): String representation of the full byte sequence.
+        highlighted_bytes_str (str): String representation of the matched bytes.
+        highlighted_bytes (BytesMatch): The BytesMatch object for context.
+
+    Returns:
+        int: The index in the surrounding string where the highlighted bytes start, or -1 if not found.
     """
     # Start a few chars in to avoid errors: sometimes we're searching for 1 or 2 bytes and there's a false positive
     # in the extra bytes. Tthis isn't perfect - it's starting us at the first index into the *bytes* that's safe to
@@ -155,7 +252,7 @@ def _find_str_rep_of_bytes(surrounding_bytes_str: str, highlighted_bytes_str: st
 
     # TODO: Somehow \' and ' don't always come out the same :(
     if highlight_idx == -1:
-        log.info(f"Failed to find highlighted_bytes in first pass so deleting single quotes and retrying. " + \
+        log.info(f"Failed to find highlighted_bytes in first pass so deleting single quotes and retrying. " +
                   "Highlighting may be off by a few chars,")
 
         surrounding_bytes_str = surrounding_bytes_str.replace("\\'", "'")

yaralyzer/helpers/dict_helper.py

@@ -1,9 +1,8 @@
 """
 Help with dicts.
 """
-from numbers import Number
 
 
 def get_dict_key_by_value(_dict: dict, value):
-    """Inverse of the usual dict operation"""
+    """Inverse of the usual dict operation."""
     return list(_dict.keys())[list(_dict.values()).index(value)]

yaralyzer/helpers/file_helper.py

@@ -7,12 +7,12 @@ from typing import List, Optional
 
 
 def timestamp_for_filename() -> str:
-    """Returns a string showing current time in a file name friendly format"""
+    """Returns a string showing current time in a file name friendly format."""
     return datetime.now().strftime("%Y-%m-%dT%H.%M.%S")
 
 
 def files_in_dir(dir: str, with_extname: Optional[str] = None) -> List[str]:
-    """paths for non dot files, optionally ending in 'with_extname'"""
+    """paths for non dot files, optionally ending in 'with_extname'."""
     files = [path.join(dir, path.basename(file)) for file in listdir(dir) if not file.startswith('.')]
     files = [file for file in files if not path.isdir(file)]
 
@@ -27,7 +27,7 @@ def files_with_extname(files: List[str], extname: str) -> List[str]:
 
 
 def load_word_list(file_path):
-    """For very simple files (1 col CSVs, if you wll)"""
+    """For very simple files (1 col CSVs, if you will)."""
     with open(file_path, 'r') as f:
         return [line.rstrip().lstrip() for line in f.readlines()]
 

yaralyzer/helpers/list_helper.py

@@ -2,6 +2,7 @@
 Help with lists.
 """
 
+
 def flatten(a):
     """From https://www.geeksforgeeks.org/python/python-flatten-list-to-individual-elements/"""
     return_value = []

yaralyzer/helpers/rich_text_helper.py

@@ -1,5 +1,6 @@
 """
 Methods to handle turning various objects into Rich text/table/etc representations
+
 Rich colors: https://rich.readthedocs.io/en/stable/appendix/colors.html
 TODO: interesting colors # row_styles[0] = 'reverse bold on color(144)' <-
 """
@@ -40,13 +41,13 @@ def na_txt(style: Union[str, Style] = 'white'):
     return Text('N/A', style=style)
 
 
-def prefix_with_plain_text_obj(_str: str, style: str, root_style=None) -> Text:
-    """Sometimes you need a Text() object to start plain lest the underline or whatever last forever"""
+def prefix_with_style(_str: str, style: str, root_style=None) -> Text:
+    """Sometimes you need a Text() object to start plain lest the underline or whatever last forever."""
     return Text('', style=root_style or 'white') + Text(_str, style)
 
 
 def meter_style(meter_pct):
-    """For coloring numbers between 0 and 100 (AKA pcts). Closer to 100 means greener, closer to 0.0 means bluer"""
+    """For coloring numbers between 0 and 100 (AKA pcts). Closer to 100 means greener, closer to 0.0 means bluer."""
     if meter_pct > 100 or meter_pct < 0:
         log.warning(f"Invalid meter_pct: {meter_pct}")
 
@@ -61,7 +62,7 @@ def meter_style(meter_pct):
     return style
 
 
-def unprintable_byte_to_text(code: str, style='') -> Text:
+def unprintable_byte_to_text(code: str, style: str = '') -> Text:
     """Used with ASCII escape codes and the like, gives colored results like '[NBSP]'."""
     style = BYTES_HIGHLIGHT if style == BYTES_BRIGHTEST else style
     txt = Text('[', style=style)
@@ -70,7 +71,7 @@ def unprintable_byte_to_text(code: str, style='') -> Text:
     return txt
 
 
-def dim_if(txt: Union[str, Text], is_dim: bool, style: Union[str, None]=None):
+def dim_if(txt: Union[str, Text], is_dim: bool, style: Union[str, None] = None):
     """Apply 'dim' style if 'is_dim'. 'style' overrides for Text and applies for strings."""
     txt = txt.copy() if isinstance(txt, Text) else Text(txt, style=style or '')
 
@@ -81,7 +82,7 @@ def dim_if(txt: Union[str, Text], is_dim: bool, style: Union[str, None]=None):
 
 
 def reverse_color(style: Style) -> Style:
-    """Reverses the color for a given style"""
+    """Reverses the color for a given style."""
     return Style(color=style.bgcolor, bgcolor=style.color, underline=style.underline, bold=style.bold)
 
 
@@ -95,25 +96,26 @@ def show_color_theme(styles: dict) -> None:
     console.print(Panel('The Yaralyzer Color Theme', style='reverse'))
 
     colors = [
-        prefix_with_plain_text_obj(name[:MAX_THEME_COL_SIZE], style=str(style)).append(' ')
+        prefix_with_style(name[:MAX_THEME_COL_SIZE], style=str(style)).append(' ')
         for name, style in styles.items()
         if name not in ['reset', 'repr_url']
     ]
 
-    console.print(Columns(colors, column_first=True, padding=(0,5), equal=True))
+    console.print(Columns(colors, column_first=True, padding=(0, 5), equal=True))
 
 
 def size_text(num_bytes: int) -> Text:
-    """Convert a number of bytes into (e.g.) 54,213 bytes (52 KB)"""
-    kb_txt = prefix_with_plain_text_obj("{:,.1f}".format(num_bytes / 1024), style='bright_cyan', root_style='white')
+    """Convert a number of bytes into (e.g.) 54,213 bytes (52 KB)."""
+    kb_txt = prefix_with_style("{:,.1f}".format(num_bytes / 1024), style='bright_cyan', root_style='white')
     kb_txt.append(' kb ')
     bytes_txt = Text('(', 'white') + size_in_bytes_text(num_bytes) + Text(')')
     return kb_txt + bytes_txt
 
 
 def size_in_bytes_text(num_bytes: int) -> Text:
-    return  Text(f"{num_bytes:,d}", 'number').append(' bytes', style='white')
+    return Text(f"{num_bytes:,d}", 'number').append(' bytes', style='white')
 
 
 def newline_join(texts: List[Text]) -> Text:
+    """Join a list of Text objects with newlines between them."""
     return Text("\n").join(texts)

yaralyzer/helpers/string_helper.py

@@ -17,7 +17,7 @@ def line_count(_string: str) -> int:
 
 
 def hex_to_string(_string: str) -> str:
-    """String '0D 0A 25 25 45 4F 46 0D 0A' becomes '\r\n%%EOF\r\n'"""
+    r"""String '0D 0A 25 25 45 4F 46 0D 0A' becomes '\r\n%%EOF\r\n'"""
     return bytearray.fromhex(_string.replace(' ', '')).decode()
 
 

yaralyzer/output/file_export.py

@@ -1,3 +1,4 @@
+"""Functions to export Yaralyzer results to various file formats."""
 import json
 import time
 from os import path
@@ -83,7 +84,7 @@ def invoke_rich_export(export_method, output_file_basepath) -> str:
     kwargs.update({'clear': False})
 
     if 'svg' in method_name:
-        kwargs.update({'title': path.basename(output_file_path) })
+        kwargs.update({'title': path.basename(output_file_path)})
 
     # Invoke it
     log_and_print(f"Invoking Rich.console.{method_name}('{output_file_path}') with kwargs: '{kwargs}'...")