yaralyzer 1.0.6__tar.gz → 1.0.8__tar.gz

{yaralyzer-1.0.6 → yaralyzer-1.0.8}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # NEXT RELEASE
 
+### 1.0.8
+* Bump `python-dotenv` to v1.1.1
+* Use `mkdocs` and `lazydocs` to build automatic API documentation at https://michelcrypt4d4mus.github.io/yaralyzer/
+* Drop python 3.9 support (required by `mkdocs-awesome-nav` package)
+
+### 1.0.7
+* Add `Changelog` to PyPi URLs, add some more PyPi classifiers
+* Add `.flake8` config file and fix style errors
+* Rename `prefix_with_plain_text_obj()` to `prefix_with_style()`
+
 ### 1.0.6
 * Add `Environment :: Console` and `Programming Language :: Python` to PyPi classifiers
 * Add `LICENSE` to PyPi package

{yaralyzer-1.0.6 → yaralyzer-1.0.8}/PKG-INFO

@@ -1,31 +1,33 @@
 Metadata-Version: 2.1
 Name: yaralyzer
-Version: 1.0.6
-Summary: Visualize and force decode YARA and regex matches found in a file or byte stream. With colors. Lots of colors.
+Version: 1.0.8
+Summary: Visualize and force decode YARA and regex matches found in a file or byte stream with colors. Lots of colors.
 Home-page: https://github.com/michelcrypt4d4mus/yaralyzer
 License: GPL-3.0-or-later
-Keywords: ascii art,binary,character encoding,color,cybersecurity,data visualization,decode,DFIR,encoding,infosec,maldoc,malicious,malware,malware analysis,regex,regular expressions,reverse engineering,reversing,security,threat assessment,threat hunting,threat intelligence,threat research,visualization,yara
+Keywords: ascii art,binary,character encoding,color,cybersecurity,data visualization,decode,DFIR,encoding,infosec,maldoc,malicious,malware,malware analysis,regex,regular expressions,reverse engineering,reversing,security,threat assessment,threat hunting,threat intelligence,threat research,threatintel,visualization,yara
 Author: Michel de Cryptadamus
 Author-email: michel@cryptadamus.com
-Requires-Python: >=3.9,<4.0
+Requires-Python: >=3.10,<4.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Information Technology
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Artistic Software
 Classifier: Topic :: Scientific/Engineering :: Visualization
 Classifier: Topic :: Security
 Requires-Dist: chardet (>=5.0.0,<6.0.0)
-Requires-Dist: python-dotenv (>=0.21.0,<0.22.0)
+Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
 Requires-Dist: rich (>=14.1.0,<15.0.0)
 Requires-Dist: rich-argparse-plus (>=0.3.1,<0.4.0)
 Requires-Dist: yara-python (>=4.5.4,<5.0.0)
-Project-URL: Documentation, https://github.com/michelcrypt4d4mus/yaralyzer
+Project-URL: Changelog, https://github.com/michelcrypt4d4mus/yaralyzer/blob/master/CHANGELOG.md
+Project-URL: Documentation, https://michelcrypt4d4mus.github.io/yaralyzer/
 Project-URL: Repository, https://github.com/michelcrypt4d4mus/yaralyzer
 Description-Content-Type: text/markdown
 
@@ -117,6 +119,9 @@ for bytes_match, bytes_decoder in yaralyzer.match_iterator():
     do_stuff()
 ```
 
+#### API Documentation
+Auto generated documentation for Yaralyzer's various classes and methods can be found [here](https://michelcrypt4d4mus.github.io/yaralyzer/).
+
 # Example Output
 The Yaralyzer can export visualizations to HTML, ANSI colored text, and SVG vector images using the file export functionality that comes with [Rich](https://github.com/Textualize/rich) as well as a (somewhat limited) plain text JSON format. SVGs can be turned into `png` format images with a tool like [Inkscape](https://inkscape.org/) or `cairosvg`. In our experience they both work though we've seen some glitchiness with `cairosvg`.
 

{yaralyzer-1.0.6 → yaralyzer-1.0.8}/README.md

@@ -86,6 +86,9 @@ for bytes_match, bytes_decoder in yaralyzer.match_iterator():
     do_stuff()
 ```
 
+#### API Documentation
+Auto generated documentation for Yaralyzer's various classes and methods can be found [here](https://michelcrypt4d4mus.github.io/yaralyzer/).
+
 # Example Output
 The Yaralyzer can export visualizations to HTML, ANSI colored text, and SVG vector images using the file export functionality that comes with [Rich](https://github.com/Textualize/rich) as well as a (somewhat limited) plain text JSON format. SVGs can be turned into `png` format images with a tool like [Inkscape](https://inkscape.org/) or `cairosvg`. In our experience they both work though we've seen some glitchiness with `cairosvg`.
 

{yaralyzer-1.0.6 → yaralyzer-1.0.8}/pyproject.toml

@@ -1,13 +1,35 @@
 [tool.poetry]
 name = "yaralyzer"
-version = "1.0.6"
-description = "Visualize and force decode YARA and regex matches found in a file or byte stream. With colors. Lots of colors."
+version = "1.0.8"
+description = "Visualize and force decode YARA and regex matches found in a file or byte stream with colors. Lots of colors."
 authors = ["Michel de Cryptadamus <michel@cryptadamus.com>"]
 readme = "README.md"
 license = "GPL-3.0-or-later"
+
 homepage = "https://github.com/michelcrypt4d4mus/yaralyzer"
 repository = "https://github.com/michelcrypt4d4mus/yaralyzer"
-documentation = "https://github.com/michelcrypt4d4mus/yaralyzer"
+documentation = "https://michelcrypt4d4mus.github.io/yaralyzer/"
+
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Intended Audience :: Information Technology",
+    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Artistic Software",
+    "Topic :: Security",
+    "Topic :: Scientific/Engineering :: Visualization",
+]
+
+include = [
+    "CHANGELOG.md",
+    "LICENSE",
+    ".yaralyzer.example"
+]
 
 keywords = [
     "ascii art",
@@ -33,46 +55,65 @@ keywords = [
     "threat hunting",
     "threat intelligence",
     "threat research",
+    "threatintel",
     "visualization",
     "yara",
 ]
 
-classifiers = [
-    "Development Status :: 5 - Production/Stable",
-    "Environment :: Console",
-    "Intended Audience :: Information Technology",
-    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
-    "Programming Language :: Python",
-    "Topic :: Artistic Software",
-    "Topic :: Security",
-    "Topic :: Scientific/Engineering :: Visualization",
-]
-
-include = [
-    "CHANGELOG.md",
-    "LICENSE",
-    ".yaralyzer.example"
-]
-
 
+####################
+#   Dependencies   #
+####################
 [tool.poetry.dependencies]
-python = "^3.9"
+python = "^3.10"
 chardet = ">=5.0.0,<6.0.0"
-#plyara = "^2.1.1"
-python-dotenv = "^0.21.0"
+python-dotenv = "^1.1.1"
 rich = "^14.1.0"
 rich-argparse-plus = "^0.3.1"
 yara-python = "^4.5.4"
+#plyara = "^2.1.1"  # TODO: use plyara for YARA rule parsing and validation
 
 [tool.poetry.group.dev.dependencies]
+flake8 = "^7.3.0"
+lazydocs = "^0.4.8"
+mkdocs = "^1.6.1"
+mkdocs-awesome-nav = "^3.1.2"
+mkdocs-include-markdown-plugin = "^7.1.7"
+mkdocs-material = "^9.6.19"
+pydocstyle = "^6.3.0"
 pytest = "^7.1.3"
 
 
+#############
+#  Scripts  #
+#############
 [tool.poetry.scripts]
 yaralyze = 'yaralyzer:yaralyze'
 yaralyzer_show_color_theme = 'yaralyzer.helpers.rich_text_helper:yaralyzer_show_color_theme'
 
 
+###############
+#  PyPi URLs  #
+###############
+[tool.poetry.urls]
+Changelog = "https://github.com/michelcrypt4d4mus/yaralyzer/blob/master/CHANGELOG.md"
+
+
+#################
+#  Build Stuff  #
+#################
 [build-system]
-requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
+requires = ["poetry-core"]
+
+[tool.pydocstyle]
+match-dir = "yaralyzer"
+ignore = [
+    "D200",  # One-line docstring should fit on one line with quotes (found 3)
+    "D203",  # 1 blank line required before class docstring"
+    "D212",  # Multi-line docstring summary should start at the first line
+    "D401",  # First line should be in imperative mood"
+    "D406",  # Section name should end with a newline
+    "D407",  # Missing dashed underline after section
+    "D413",  # Missing blank line after last section
+]

{yaralyzer-1.0.6 → yaralyzer-1.0.8}/yaralyzer/__init__.py

@@ -11,11 +11,9 @@ if not environ.get('INVOKED_BY_PYTEST', False):
             load_dotenv(dotenv_path=dotenv_file)
             break
 
-from yaralyzer.config import YaralyzerConfig
 from yaralyzer.output.file_export import export_json, invoke_rich_export
 from yaralyzer.output.rich_console import console
 from yaralyzer.util.argument_parser import get_export_basepath, parse_arguments
-from yaralyzer.util.logging import log
 from yaralyzer.yara.yara_rule_builder import HEX, REGEX
 from yaralyzer.yaralyzer import Yaralyzer
 
@@ -26,6 +24,11 @@ PDFALYZER_MSG_TXT.append('https://github.com/michelcrypt4d4mus/pdfalyzer\n', sty
 
 
 def yaralyze():
+    """
+    Entry point for yaralyzer when invoked as a script.
+
+    Args are parsed from the command line and environment variables. See yaralyzer --help for details.
+    """
     args = parse_arguments()
     output_basepath = None
 

{yaralyzer-1.0.6 → yaralyzer-1.0.8}/yaralyzer/bytes_match.py

@@ -1,10 +1,4 @@
-"""
-Simple class to keep track of regex matches against binary data.  Basically an re.match object with
-some (not many) extra bells and whistles, most notably the surrounding_bytes property.
-
-pre_capture_len and post_capture_len refer to the regex sections before and after the capture group,
-e.g. a regex like '123(.*)x:' would have pre_capture_len of 3 and post_capture_len of 2.
-"""
+"""BytesMatch class for tracking regex and YARA matches against binary data."""
 import re
 from typing import Iterator, Optional
 
@@ -13,25 +7,43 @@ from rich.text import Text
 from yara import StringMatch, StringMatchInstance
 
 from yaralyzer.config import YaralyzerConfig
-from yaralyzer.helpers.rich_text_helper import prefix_with_plain_text_obj
+from yaralyzer.helpers.rich_text_helper import prefix_with_style
 from yaralyzer.output.file_hashes_table import bytes_hashes_table
 from yaralyzer.output.rich_console import ALERT_STYLE, GREY_ADDRESS
 
 
 class BytesMatch:
+    """
+    Simple class to keep track of regex matches against binary data.
+
+    Basically an re.match object with some (not many) extra bells and whistles, most notably
+    the surrounding_bytes property.
+
+    pre_capture_len and post_capture_len refer to the regex sections before and after the capture group,
+    e.g. a regex like '123(.*)x:' would have pre_capture_len of 3 and post_capture_len of 2.
+    """
+
     def __init__(
-            self,
-            matched_against: bytes,
-            start_idx: int,
-            length: int,
-            label: str,
-            ordinal: int,
-            match: Optional[re.Match] = None,  # It's rough to get the regex from yara :(
-            highlight_style: str = YaralyzerConfig.HIGHLIGHT_STYLE
-        ) -> None:
-        """
-        Ordinal means it's the Nth match with this regex (not super important but useful)
-        YARA makes it a little rouch to get the actual regex that matched. Can be done with plyara eventually.
+        self,
+        matched_against: bytes,
+        start_idx: int,
+        length: int,
+        label: str,
+        ordinal: int,
+        match: Optional[re.Match] = None,  # It's rough to get the regex from yara :(
+        highlight_style: str = YaralyzerConfig.HIGHLIGHT_STYLE
+    ) -> None:
+        """
+        Initialize a BytesMatch object representing a match against binary data.
+
+        Args:
+            matched_against (bytes): The full byte sequence that was searched.
+            start_idx (int): Start index of the match in the byte sequence.
+            length (int): Length of the match in bytes.
+            label (str): Label for the match (e.g., regex or YARA rule name).
+            ordinal (int): The Nth match for this pattern.
+            match (Optional[re.Match]): Regex match object, if available.
+            highlight_style (str): Style to use for highlighting the match.
         """
         self.matched_against: bytes = matched_against
         self.start_idx: int = start_idx
@@ -52,25 +64,50 @@ class BytesMatch:
 
     @classmethod
     def from_regex_match(
-            cls,
-            matched_against: bytes,
-            match: re.Match,
-            ordinal: int,
-            highlight_style: str = YaralyzerConfig.HIGHLIGHT_STYLE
-        ) -> 'BytesMatch':
+        cls,
+        matched_against: bytes,
+        match: re.Match,
+        ordinal: int,
+        highlight_style: str = YaralyzerConfig.HIGHLIGHT_STYLE
+    ) -> 'BytesMatch':
+        """
+        Create a BytesMatch from a regex match object.
+
+        Args:
+            matched_against (bytes): The bytes searched.
+            match (re.Match): The regex match object.
+            ordinal (int): The Nth match for this pattern.
+            highlight_style (str): Style for highlighting.
+
+        Returns:
+            BytesMatch: The constructed BytesMatch instance.
+        """
         return cls(matched_against, match.start(), len(match[0]), match.re.pattern, ordinal, match, highlight_style)
 
     @classmethod
     def from_yara_str(
-            cls,
-            matched_against: bytes,
-            rule_name: str,
-            yara_str_match: StringMatch,
-            yara_str_match_instance: StringMatchInstance,
-            ordinal: int,
-            highlight_style: str = YaralyzerConfig.HIGHLIGHT_STYLE
-        ) -> 'BytesMatch':
-        """Build a BytesMatch from a yara string match. 'matched_against' is the set of bytes yara was run against."""
+        cls,
+        matched_against: bytes,
+        rule_name: str,
+        yara_str_match: StringMatch,
+        yara_str_match_instance: StringMatchInstance,
+        ordinal: int,
+        highlight_style: str = YaralyzerConfig.HIGHLIGHT_STYLE
+    ) -> 'BytesMatch':
+        """
+        Build a BytesMatch from a YARA string match instance.
+
+        Args:
+            matched_against (bytes): The bytes searched.
+            rule_name (str): Name of the YARA rule.
+            yara_str_match (StringMatch): YARA string match object.
+            yara_str_match_instance (StringMatchInstance): Instance of the string match.
+            ordinal (int): The Nth match for this pattern.
+            highlight_style (str): Style for highlighting.
+
+        Returns:
+            BytesMatch: The constructed BytesMatch instance.
+        """
         pattern_label = yara_str_match.identifier
 
         # Don't duplicate the labeling if rule_name and yara_str are the same
@@ -89,12 +126,22 @@ class BytesMatch:
 
     @classmethod
     def from_yara_match(
-            cls,
-            matched_against: bytes,
-            yara_match: dict,
-            highlight_style: str = YaralyzerConfig.HIGHLIGHT_STYLE
-        ) -> Iterator['BytesMatch']:
-        """Iterator w/a BytesMatch for each string returned as part of a YARA match result dict."""
+        cls,
+        matched_against: bytes,
+        yara_match: dict,
+        highlight_style: str = YaralyzerConfig.HIGHLIGHT_STYLE
+    ) -> Iterator['BytesMatch']:
+        """
+        Yield a BytesMatch for each string returned as part of a YARA match result dict.
+
+        Args:
+            matched_against (bytes): The bytes searched.
+            yara_match (dict): YARA match result dictionary.
+            highlight_style (str): Style for highlighting.
+
+        Yields:
+            BytesMatch: For each string match in the YARA result.
+        """
         i = 0  # For numbered labeling
 
         # yara-python's internals changed with 4.3.0: https://github.com/VirusTotal/yara-python/releases/tag/v4.3.0
@@ -102,28 +149,43 @@ class BytesMatch:
             for yara_str_match_instance in yara_str_match.instances:
                 i += 1
 
-                yield(cls.from_yara_str(
+                yield cls.from_yara_str(
                     matched_against,
                     yara_match['rule'],
                     yara_str_match,
                     yara_str_match_instance,
                     i,
-                    highlight_style))
+                    highlight_style
+                )
 
     def style_at_position(self, idx) -> str:
-        """Get the style for the byte at position idx within the matched bytes"""
+        """
+        Get the style for the byte at position idx within the matched bytes.
+
+        Args:
+            idx (int): Index within the surrounding bytes.
+
+        Returns:
+            str: The style to use for this byte (highlight or greyed out).
+        """
         if idx < self.highlight_start_idx or idx >= self.highlight_end_idx:
             return GREY_ADDRESS
         else:
             return self.highlight_style
 
     def location(self) -> Text:
-        """Returns a Text obj like '(start idx: 348190, end idx: 348228)'"""
-        location_txt = prefix_with_plain_text_obj(
+        """
+        Get a styled Text object describing the start and end index of the match.
+
+        Returns:
+            Text: Rich Text object like '(start idx: 348190, end idx: 348228)'.
+        """
+        location_txt = prefix_with_style(
             f"(start idx: ",
             style='off_white',
             root_style='decode.subheading'
         )
+
         location_txt.append(str(self.start_idx), style='number')
         location_txt.append(', end idx: ', style='off_white')
         location_txt.append(str(self.end_idx), style='number')
@@ -131,13 +193,26 @@ class BytesMatch:
         return location_txt
 
     def is_decodable(self) -> bool:
-        """True if SUPPRESS_DECODES_TABLE is false and length of self.bytes is between MIN/MAX_DECODE_LENGTH"""
+        """
+        Determine if the matched bytes should be decoded.
+
+        Whether the bytes are decodable depends on whether SUPPRESS_DECODES_TABLE is set
+        and whether the match length is between MIN/MAX_DECODE_LENGTH.
+
+        Returns:
+            bool: True if decodable, False otherwise.
+        """
         return self.match_length >= YaralyzerConfig.args.min_decode_length \
            and self.match_length <= YaralyzerConfig.args.max_decode_length \
            and not YaralyzerConfig.args.suppress_decodes_table
 
     def bytes_hashes_table(self) -> Table:
-        """Helper function to build the MD5/SHA table for self.bytes"""
+        """
+        Build a table of MD5/SHA hashes for the matched bytes.
+
+        Returns:
+            Table: Rich Table object with hashes.
+        """
         return bytes_hashes_table(
             self.bytes,
             self.location().plain,
@@ -145,7 +220,12 @@ class BytesMatch:
         )
 
     def suppression_notice(self) -> Text:
-        """Generate a message for when there are too few/too many bytes"""
+        """
+        Generate a message for when the match is too short or too long to decode.
+
+        Returns:
+            Text: Rich Text object with the suppression notice.
+        """
         txt = self.__rich__()
 
         if self.match_length < YaralyzerConfig.args.min_decode_length:
@@ -157,7 +237,12 @@ class BytesMatch:
         return txt
 
     def to_json(self) -> dict:
-        """Convert this BytesMatch to a JSON-serializable dict."""
+        """
+        Convert this BytesMatch to a JSON-serializable dictionary.
+
+        Returns:
+            dict: Dictionary representation of the match, suitable for JSON serialization.
+        """
         json_dict = {
             'label': self.label,
             'match_length': self.match_length,
@@ -176,7 +261,13 @@ class BytesMatch:
         return json_dict
 
     def _find_surrounding_bytes(self, num_before: Optional[int] = None, num_after: Optional[int] = None) -> None:
-        """Find the surrounding bytes, making sure not to step off the beginning or end"""
+        """
+        Find and set the bytes surrounding the match, ensuring indices stay within bounds.
+
+        Args:
+            num_before (Optional[int]): Number of bytes before the match to include.
+            num_after (Optional[int]): Number of bytes after the match to include.
+        """
         num_after = num_after or num_before or YaralyzerConfig.args.surrounding_bytes
         num_before = num_before or YaralyzerConfig.args.surrounding_bytes
         self.surrounding_start_idx: int = max(self.start_idx - num_before, 0)
@@ -184,11 +275,13 @@ class BytesMatch:
         self.surrounding_bytes: bytes = self.matched_against[self.surrounding_start_idx:self.surrounding_end_idx]
 
     def __rich__(self) -> Text:
-        headline = prefix_with_plain_text_obj(str(self.match_length), style='number', root_style='decode.subheading')
+        """Get a rich Text representation of the match for display."""
+        headline = prefix_with_style(str(self.match_length), style='number', root_style='decode.subheading')
         headline.append(f" bytes matching ")
         headline.append(f"{self.label} ", style=ALERT_STYLE if self.highlight_style == ALERT_STYLE else 'regex')
         headline.append('at ')
         return headline + self.location()
 
     def __str__(self):
+        """Plain text (no rich colors) representation of the match for display."""
         return self.__rich__().plain

{yaralyzer-1.0.6 → yaralyzer-1.0.8}/yaralyzer/config.py

@@ -1,3 +1,6 @@
+"""
+Configuration management for Yaralyzer.
+"""
 import logging
 from argparse import ArgumentParser, Namespace
 from os import environ
@@ -15,16 +18,19 @@ MEGABYTE = 1024 * KILOBYTE
 
 def config_var_name(env_var: str) -> str:
     """
-    Get the name of env_var and strip off 'YARALYZER_', e.g.:
-        SURROUNDING_BYTES_ENV_VAR = 'YARALYZER_SURROUNDING_BYTES'
-        config_var_name(SURROUNDING_BYTES_ENV_VAR) => 'SURROUNDING_BYTES'
+    Get the name of env_var and strip off 'YARALYZER_' prefix.
+
+    Example:
+        $ SURROUNDING_BYTES_ENV_VAR = 'YARALYZER_SURROUNDING_BYTES'
+        $ config_var_name(SURROUNDING_BYTES_ENV_VAR) => 'SURROUNDING_BYTES'
+
     """
     env_var = env_var.removeprefix("YARALYZER_")
     return f'{env_var=}'.partition('=')[0]
 
 
 def is_env_var_set_and_not_false(var_name):
-    """Returns True if var_name is not empty and set to anything other than 'false' (capitalization agnostic)"""
+    """Return True if var_name is not empty and set to anything other than 'false' (capitalization agnostic)."""
     if var_name in environ:
         var_value = environ[var_name]
         return var_value is not None and len(var_value) > 0 and var_value.lower() != 'false'
@@ -33,11 +39,13 @@ def is_env_var_set_and_not_false(var_name):
 
 
 def is_invoked_by_pytest():
-    """Return true if pytest is running"""
+    """Return true if pytest is running."""
     return is_env_var_set_and_not_false(PYTEST_FLAG)
 
 
 class YaralyzerConfig:
+    """Handles parsing of command line args and environment variables for Yaralyzer."""
+
     # Passed through to yara.set_config()
     DEFAULT_MAX_MATCH_LENGTH = 100 * KILOBYTE
     DEFAULT_YARA_STACK_SIZE = 2 * 65536
@@ -76,11 +84,13 @@ class YaralyzerConfig:
 
     @classmethod
     def set_argument_parser(cls, parser: ArgumentParser) -> None:
+        """Sets the _argument_parser instance variable that will be used to parse command line args."""
         cls._argument_parser: ArgumentParser = parser
         cls._argparse_keys: List[str] = sorted([action.dest for action in parser._actions])
 
     @classmethod
     def set_args(cls, args: Namespace) -> None:
+        """Set the args class instance variable and update args with any environment variable overrides."""
         cls.args = args
 
         for option in cls._argparse_keys:
@@ -91,7 +101,7 @@ class YaralyzerConfig:
             env_var = f"{YARALYZER}_{option.upper()}"
             env_value = environ.get(env_var)
             default_value = cls.get_default_arg(option)
-            #print(f"option: {option}, arg_value: {arg_value}, env_var: {env_var}, env_value: {env_value}, default: {default_value}")
+            # print(f"option: {option}, arg_value: {arg_value}, env_var: {env_var}, env_value: {env_value}, default: {default_value}")  # noqa: E501
 
             # TODO: as is you can't override env vars with CLI args
             if isinstance(arg_value, bool):
@@ -105,9 +115,11 @@ class YaralyzerConfig:
 
     @classmethod
     def set_default_args(cls):
+        """Set args to their defaults as if parsed from the command line."""
         cls.set_args(cls._argument_parser.parse_args(['dummy']))
 
     @classmethod
     def get_default_arg(cls, arg: str) -> Any:
+        """Return the default value for arg as defined by a DEFAULT_ style class variable."""
         default_var = f"DEFAULT_{arg.upper()}"
         return vars(cls).get(default_var)